diff --git a/packages/typescript/enums/objectFlags.d.ts b/packages/typescript/enums/objectFlags.d.ts index 45303ee1ce1a4..ac8ff7d3d315b 100644 --- a/packages/typescript/enums/objectFlags.d.ts +++ b/packages/typescript/enums/objectFlags.d.ts @@ -34,9 +34,7 @@ export declare enum ObjectFlags { ContainsSpread = 1 << 22, ObjectRestType = 1 << 23, IsClassInstanceClone = 1 << 26, - IdenticalBaseTypeCalculated = 1 << 27, IdenticalBaseTypeExists = 1 << 28, - FromTypeNode = 1 << 29, IsGenericTypeComputed = 1 << 22, IsGenericObjectType = 1 << 23, IsGenericIndexType = 1 << 24, diff --git a/packages/typescript/enums/objectFlags.js b/packages/typescript/enums/objectFlags.js index 380ea72af1c7d..050bb675d623c 100644 --- a/packages/typescript/enums/objectFlags.js +++ b/packages/typescript/enums/objectFlags.js @@ -34,9 +34,7 @@ export var ObjectFlags; ObjectFlags[ObjectFlags["ContainsSpread"] = 4194304] = "ContainsSpread"; ObjectFlags[ObjectFlags["ObjectRestType"] = 8388608] = "ObjectRestType"; ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 67108864] = "IsClassInstanceClone"; - ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 134217728] = "IdenticalBaseTypeCalculated"; ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 268435456] = "IdenticalBaseTypeExists"; - ObjectFlags[ObjectFlags["FromTypeNode"] = 536870912] = "FromTypeNode"; ObjectFlags[ObjectFlags["IsGenericTypeComputed"] = 4194304] = "IsGenericTypeComputed"; ObjectFlags[ObjectFlags["IsGenericObjectType"] = 8388608] = "IsGenericObjectType"; ObjectFlags[ObjectFlags["IsGenericIndexType"] = 16777216] = "IsGenericIndexType"; diff --git a/tools/scripts/tsc/options.ts b/tools/scripts/tsc/options.ts index f187939351af1..4b6412331c134 100644 --- a/tools/scripts/tsc/options.ts +++ b/tools/scripts/tsc/options.ts @@ -1697,7 +1697,7 @@ export const options: OptionsModel = { group: "commonOptionsWithBuild", category: diagnostic("Command-line Options"), description: diagnostic("Set the number of checkers per project."), - defaultValueDescription: diagnostic("4, unless --singleThreaded is passed."), + defaultValueDescription: diagnostic("Based on the available CPUs and the size of the project, unless --singleThreaded is passed."), minValue: 1, }, }, diff --git a/tsc/internal/api/enum_values_generated.go b/tsc/internal/api/enum_values_generated.go index 1697a479539a5..709893c44f9ac 100644 --- a/tsc/internal/api/enum_values_generated.go +++ b/tsc/internal/api/enum_values_generated.go @@ -242,9 +242,7 @@ func main() { "ContainsSpread": toInt32(checker.ObjectFlagsContainsSpread), "ObjectRestType": toInt32(checker.ObjectFlagsObjectRestType), "IsClassInstanceClone": toInt32(checker.ObjectFlagsIsClassInstanceClone), - "IdenticalBaseTypeCalculated": toInt32(checker.ObjectFlagsIdenticalBaseTypeCalculated), "IdenticalBaseTypeExists": toInt32(checker.ObjectFlagsIdenticalBaseTypeExists), - "FromTypeNode": toInt32(checker.ObjectFlagsFromTypeNode), "IsGenericTypeComputed": toInt32(checker.ObjectFlagsIsGenericTypeComputed), "IsGenericObjectType": toInt32(checker.ObjectFlagsIsGenericObjectType), "IsGenericIndexType": toInt32(checker.ObjectFlagsIsGenericIndexType), diff --git a/tsc/internal/api/session.go b/tsc/internal/api/session.go index 4438ab668486f..ffef73437f19f 100644 --- a/tsc/internal/api/session.go +++ b/tsc/internal/api/session.go @@ -340,12 +340,10 @@ func (sd *snapshotData) newTypeResponse(projectID project.Handle, t *checker.Typ resp.AliasSymbol = newSymbolReference(t.Alias().Symbol()) } if t.ObjectFlags()&checker.ObjectFlagsMapped != 0 { - mapped := t.AsMappedType() - mapped.ResolveComponents(c, t) - resp.TypeParameter = sd.registerType(projectID, mapped.TypeParameter()) - resp.ConstraintType = sd.registerType(projectID, mapped.ConstraintType()) - resp.NameType = sd.registerType(projectID, mapped.NameType()) - resp.TemplateType = sd.registerType(projectID, mapped.TemplateType()) + resp.TypeParameter = sd.registerType(projectID, c.GetTypeParameterOfMappedType(t)) + resp.ConstraintType = sd.registerType(projectID, c.GetConstraintTypeOfMappedType(t)) + resp.NameType = sd.registerType(projectID, c.GetNameTypeOfMappedType(t)) + resp.TemplateType = sd.registerType(projectID, c.GetTemplateTypeOfMappedType(t)) } if checker.IsTupleTypeTarget(t) { elementInfos := t.AsTupleType().ElementInfos() @@ -3271,20 +3269,20 @@ func (s *Session) handleGetConstraintOfType(ctx context.Context, params *GetType } func (s *Session) handleGetTypeParameterOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().TypeParameter() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetTypeParameterOfMappedType) } func (s *Session) handleGetConstraintTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().ConstraintType() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetConstraintTypeOfMappedType) } // @gen-proto-nullable func (s *Session) handleGetNameTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().NameType() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetNameTypeOfMappedType) } func (s *Session) handleGetTemplateTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().TemplateType() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetTemplateTypeOfMappedType) } // @gen-proto-nullable @@ -3465,6 +3463,28 @@ func (s *Session) resolveTypePropertyOfType(ctx context.Context, params *GetType return setup.sd.newTypeResponse(setup.projectID, result, setup.checker), nil } +// resolveTypePropertyOfTypeWithChecker is resolveTypePropertyOfType for a +// property the checker computes. +func (s *Session) resolveTypePropertyOfTypeWithChecker(ctx context.Context, params *GetTypePropertyParams, getter func(*checker.Checker, *checker.Type) *checker.Type) (*TypeResponse, error) { + setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) + if err != nil { + return nil, err + } + defer setup.done() + + t, err := setup.sd.resolveTypeHandle(params.Project, params.Type) + if err != nil { + return nil, err + } + + result := getter(setup.checker, t) + if result == nil { + return nil, nil + } + + return setup.sd.newTypeResponse(setup.projectID, result, setup.checker), nil +} + // resolveTypeArrayPropertyOfType resolves a type property of an array of types and returns an array of type responses. func (s *Session) resolveTypeArrayPropertyOfType(ctx context.Context, params *GetTypePropertyParams, getter func(*checker.Type) []*checker.Type) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) diff --git a/tsc/internal/ast/symbol.go b/tsc/internal/ast/symbol.go index 7c8e60e921d55..28862ff494d3d 100644 --- a/tsc/internal/ast/symbol.go +++ b/tsc/internal/ast/symbol.go @@ -223,6 +223,11 @@ func (m *SymbolMap) SymbolAt(i int) *Symbol { return symbol } +// At returns the name and symbol of the i-th entry, in insertion order. +func (m *SymbolMap) At(i int) (string, *Symbol) { + return m.KeyAt(i), m.SymbolAt(i) +} + func (m *SymbolMap) Find(key string) int { if m == nil { return -1 diff --git a/tsc/internal/ast/utilities.go b/tsc/internal/ast/utilities.go index f178903372dc2..d029159e971d3 100644 --- a/tsc/internal/ast/utilities.go +++ b/tsc/internal/ast/utilities.go @@ -33,6 +33,16 @@ func GetNodeId(node *Node) NodeId { return NodeId(id) } +// PeekNodeId returns the id of node, or 0 if it has none yet. +func PeekNodeId(node *Node) NodeId { + return NodeId(node.id.Load()) +} + +// PeekSymbolId returns the id of symbol, or 0 if it has none yet. +func PeekSymbolId(symbol *Symbol) SymbolId { + return SymbolId(symbol.id.Load()) +} + func GetSymbolId(symbol *Symbol) SymbolId { id := symbol.id.Load() if id == 0 { diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 14f8356152d83..787cc5833aff2 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -1,6 +1,7 @@ package checker import ( + "cmp" "context" "encoding/binary" "fmt" @@ -66,12 +67,40 @@ const ( TypeSystemPropertyNameWriteType TypeSystemPropertyNameInitializerIsUndefined TypeSystemPropertyNameAliasTarget + TypeSystemPropertyNameComputedPropertyName + TypeSystemPropertyNameContextChecked + TypeSystemPropertyNameVariances + TypeSystemPropertyNameStructuredMembers + TypeSystemPropertyNameSimplifiedForReading + TypeSystemPropertyNameSimplifiedForWriting + TypeSystemPropertyNameDefaultType + TypeSystemPropertyNameAwaitedType + TypeSystemPropertyNameExplicitType + TypeSystemPropertyNameBindingElementParent + TypeSystemPropertyNameCallResolution + TypeSystemPropertyNameAssertionOperand + TypeSystemPropertyNamePatternInitializer + TypeSystemPropertyNameContextualBindingPattern + TypeSystemPropertyNameBaseConstraintInWalk ) type TypeResolution struct { - target TypeSystemEntity + target TypeSystemEntity + // canonical is the member of a cycle headed by this resolution that is + // resolved first; see observeCircularHead. + canonical TypeSystemEntity + // participant records that the resolution is in cycleParticipants. + participant bool + memo *memoHeader propertyName TypeSystemPropertyName result bool + // restartHidden records that a cycle entered below this resolution of a + // module table passes through it; see resolveModuleTableMembers. + restartHidden bool + // outerSelf is one more than the index in resolutions of the outermost + // resolution of the same property of target hidden below this one, or 0; + // see popTypeResolution. + outerSelf int32 } // ContextualInfo @@ -243,14 +272,6 @@ type PropertiesTypesKey struct { includeOrigin bool } -// NonExistentPropertyKey - -type NonExistentPropertyKey struct { - propNode *ast.Node - containingType *Type - isUncheckedJS bool -} - // FlowLoopKey type FlowLoopKey struct { @@ -258,6 +279,12 @@ type FlowLoopKey struct { refKey CacheHashKey } +type flowLoopCacheEntry struct { + t *Type + // The analysis of the loop gave up because it was too deep. + tooDeep bool +} + type FlowLoopInfo struct { key FlowLoopKey types []*Type @@ -549,8 +576,21 @@ type WideningContext struct { } type VarianceStackEntry struct { - symbol *ast.Symbol - typeParameters []*Type + symbol *ast.Symbol + resolution int // Index in Checker.resolutions of the resolution of the measurement + // The lowest index in the variance stack of a measurement in progress + // that this one or one it reached needed, and the smallest type in the + // circularity so far, as in Tarjan's algorithm for strongly connected + // components. + low int + min *ast.Symbol + minTypeParameters []*Type + discardPoint // When the measurement began + // The measurement is being repeated because the measurement from the + // canonical entry of its circularity did not reach it, so it is not + // superseded again. + remeasuring bool + provisionalStart int // Length of Checker.varianceProvisional when the measurement began } type ResolvingObjectType struct { @@ -580,6 +620,7 @@ type Program interface { GetImportHelpersImportSpecifier(path tspath.PathKey) *ast.Node SourceFileMayBeEmitted(sourceFile *ast.SourceFile, forceDtsEmit bool) bool IsSourceFileDefaultLibrary(path tspath.PathKey) bool + SkipTypeChecking(sourceFile *ast.SourceFile, ignoreNoCheck bool) bool GetProjectReferenceFromOutputDts(path tspath.PathKey) *tsoptions.SourceOutputAndProjectReference GetRedirectForResolution(file ast.HasFileName) *tsoptions.ParsedCommandLine CommonSourceDirectory() tspath.RootedDirectoryPath @@ -593,93 +634,39 @@ type Host interface { var nextCheckerID atomic.Uint32 +// Checker is a checker: the per-computation state (resolution stacks, scratch +// buffers, allocation arenas, and closures bound to this checker) layered +// over a memoStore that holds all memoized, shareable state. Multiple +// checkers may share one store; see Clone. type Checker struct { - id uint32 - program Program - compilerOptions *core.CompilerOptions - files []*ast.SourceFile - fileIndexMap map[*ast.SourceFile]int - compareSymbols func(*ast.Symbol, *ast.Symbol) int - compareSymbolChains func([]*ast.Symbol, []*ast.Symbol) int - TypeCount uint32 - SymbolCount uint32 - SignatureCount uint32 - TotalInstantiationCount uint32 - instantiationCount uint32 - memberLayoutCount uint32 - instantiationStack []*Type - conditionalConstraintDepth uint32 - inlineLevel int - serializationLevel int - currentNode *ast.Node - varianceTypeParameter *Type - languageVersion core.ScriptTarget - moduleKind core.ModuleKind - moduleResolutionKind core.ModuleResolutionKind - isInferencePartiallyBlocked bool - legacyDecorators bool - emitStandardClassFields bool - strictNullChecks bool - strictFunctionTypes bool - strictBindCallApply bool - strictPropertyInitialization bool - strictBuiltinIteratorReturn bool - noImplicitAny bool - noImplicitThis bool - useUnknownInCatchVariables bool - exactOptionalPropertyTypes bool - canCollectSymbolAliasAccessibilityData bool + *memoStore + compareSymbols func(*ast.Symbol, *ast.Symbol) int + compareSymbolChains func([]*ast.Symbol, []*ast.Symbol) int + awaitedTypeErrors uint32 // Errors computing awaited types have reported or would report; see getAwaitedTypeNoAliasEx + resolutionSerials uint32 + resolutions []resolution + instantiationStack []*Type + instantiationAborted bool // See "Instantiation limits" + instantiationAbortLog int // Length of discardLog when instantiationAborted was set + instantiationAbortRoot int // Length of instantiationStack to which a failing instantiation unwinds + readIncompleteFloor int32 // See markReadIncomplete + conditionalConstraintDepth depthLimit + baseConstraintWalk baseConstraintWalk + inlineLevel depthLimit + serializationLevel depthLimit + currentNode *ast.Node + currentNodeResolution int // 1-based index in resolutions of the resolution of currentNode, or 0; see enterCurrentNode + querySave savedCurrentNode // Saved by the query in progress made outside of checking; see startEffects + queryRoot int // 1-based index in resolutions of the computation of that query, or 0 + varianceTypeParameter *Type + // The parent last looked up in parentLateBindableKinds and its kinds, as + // members of one parent are often looked up together. + lastLateBindableParent *ast.Symbol + lastLateBindableKinds uint8 wasCanceled bool - arrayVariances []VarianceFlags - globals ast.SymbolTable evaluate evaluator.Evaluator - stringLiteralTypes map[string]*Type - numberLiteralTypes map[jsnum.Number]*Type - nanType *Type - bigintLiteralTypes map[jsnum.PseudoBigInt]*Type - enumLiteralTypes map[EnumLiteralKey]*Type - enumNaNLiteralTypes map[*ast.Symbol]*Type - indexedAccessTypes map[CacheHashKey]*Type - templateLiteralTypes map[CacheHashKey]*Type - stringMappingTypes map[StringMappingKey]*Type - uniqueESSymbolTypes map[*ast.Symbol]*Type - thisExpandoKinds map[*ast.Symbol]thisAssignmentDeclarationKind - thisExpandoLocations map[*ast.Symbol]*ast.Node - subtypeReductionCache map[CacheHashKey][]*Type - cachedTypes map[CachedTypeKey]*Type - cachedSignatures map[CachedSignatureKey]*Signature - undefinedProperties map[*ast.Symbol]*ast.Symbol - narrowedTypes map[NarrowedTypeKey]*Type - assignmentReducedTypes map[AssignmentReducedKey]*Type - discriminatedContextualTypes map[DiscriminatedContextualTypeKey]*Type - instantiationExpressionTypes map[InstantiationExpressionKey]*Type - substitutionTypes map[SubstitutionTypeKey]*Type - reverseMappedCache map[ReverseMappedTypeKey]*Type - reverseHomomorphicMappedCache map[ReverseMappedTypeKey]*Type - iterationTypesCache map[IterationTypesKey]IterationTypes - memberLayoutCache map[CacheHashKey]*MemberLayout - markerTypes collections.Set[*Type] - resolvingExplicitTypeOfSymbol collections.Set[*ast.Symbol] - constructorOrFunctionChecked collections.Set[*ast.Symbol] - undefinedSymbol *ast.Symbol - argumentsSymbol *ast.Symbol - requireSymbol *ast.Symbol - unknownSymbol *ast.Symbol - unresolvedSymbols map[string]*ast.Symbol - errorTypes map[CacheHashKey]*Type - moduleSymbols map[*ast.Node]*ast.Symbol - globalThisSymbol *ast.Symbol - symbolTableAliasCache map[symbolTableID][]*ast.Symbol - classExpressionNameTables map[ast.NodeId]ast.SymbolTable resolveName func(location *ast.Node, name string, meaning ast.SymbolFlags, nameNotFoundMessage *diagnostics.Message, isUse bool, excludeGlobals bool) *ast.Symbol resolveNameForSymbolSuggestion func(location *ast.Node, name string, meaning ast.SymbolFlags, nameNotFoundMessage *diagnostics.Message, isUse bool, excludeGlobals bool) *ast.Symbol - tupleTypes map[CacheHashKey]*Type - unionTypes map[CacheHashKey]*Type - unionOfUnionTypes map[UnionOfUnionKey]*Type - intersectionTypes map[CacheHashKey]*Type - propertiesTypes map[PropertiesTypesKey]*Type - diagnostics ast.DiagnosticsCollection - suggestionDiagnostics ast.DiagnosticsCollection symbolArena core.Arena[ast.Symbol] symbolWithDataArena core.Arena[ast.SymbolWithData] symbolExtraArena ast.SymbolExtraArena @@ -706,168 +693,67 @@ type Checker struct { layoutBaseIndices []int32 freeTypeSets *temporaryTypeSet freePropertyCounts *temporaryPropertyCounts - mergedSymbols symbolLinkStore[*ast.Symbol] - mergedExportsChecked collections.Set[*ast.Symbol] factory ast.NodeFactory - nodeLinks core.LinkStore[*ast.Node, NodeLinks] - signatureLinks nodeLinkStore[SignatureLinks] - symbolNodeLinks nodeLinkStore[SymbolNodeLinks] - typeNodeLinks nodeLinkStore[TypeNodeLinks] - enumMemberLinks core.LinkStore[*ast.Node, EnumMemberLinks] - assertionLinks core.LinkStore[*ast.Node, AssertionLinks] - arrayLiteralLinks core.LinkStore[*ast.Node, ArrayLiteralLinks] - switchStatementLinks core.LinkStore[*ast.Node, SwitchStatementLinks] - jsxElementLinks core.LinkStore[*ast.Node, JsxElementLinks] - computedNameLinks core.LinkStore[*ast.Node, ComputedNameNodeLinks] - symbolReferenceLinks core.LinkStore[*ast.Symbol, SymbolReferenceLinks] - valueSymbolLinks symbolLinkStore[ValueSymbolLinks] - mappedSymbolLinks core.LinkStore[*ast.Symbol, MappedSymbolLinks] - deferredSymbolLinks core.LinkStore[*ast.Symbol, DeferredSymbolLinks] - aliasSymbolLinks core.LinkStore[*ast.Symbol, AliasSymbolLinks] - moduleSymbolLinks core.LinkStore[*ast.Symbol, ModuleSymbolLinks] - lateBoundLinks core.LinkStore[*ast.Symbol, LateBoundLinks] - exportTypeLinks core.LinkStore[*ast.Symbol, ExportTypeLinks] - membersAndExportsLinks core.LinkStore[*ast.Symbol, MembersAndExportsLinks] - typeAliasLinks core.LinkStore[*ast.Symbol, TypeAliasLinks] - declaredTypeLinks core.LinkStore[*ast.Symbol, DeclaredTypeLinks] - spreadLinks core.LinkStore[*ast.Symbol, SpreadLinks] - varianceLinks core.LinkStore[*ast.Symbol, VarianceLinks] - ReverseMappedSymbolLinks core.LinkStore[*ast.Symbol, ReverseMappedSymbolLinks] - markedAssignmentSymbolLinks core.LinkStore[*ast.Symbol, MarkedAssignmentSymbolLinks] - symbolContainerLinks core.LinkStore[*ast.Symbol, ContainingSymbolLinks] - externalModuleContainers *externalModuleContainerIndex - sourceFileLinks core.LinkStore[*ast.SourceFile, SourceFileLinks] regExpScanner *scanner.Scanner - patternForType map[*Type]*ast.Node - contextFreeTypes map[*ast.Node]*Type - anyType *Type - autoType *Type - wildcardType *Type - blockedStringType *Type - errorType *Type - unresolvedType *Type - nonInferrableAnyType *Type - intrinsicMarkerType *Type - unknownType *Type - undefinedType *Type - undefinedWideningType *Type - missingType *Type - undefinedOrMissingType *Type - optionalType *Type - nullType *Type - nullWideningType *Type - stringType *Type - numberType *Type - bigintType *Type - regularFalseType *Type - falseType *Type - regularTrueType *Type - trueType *Type - booleanType *Type - esSymbolType *Type - voidType *Type - neverType *Type - silentNeverType *Type - implicitNeverType *Type - unreachableNeverType *Type - nonPrimitiveType *Type - stringOrNumberType *Type - stringNumberSymbolType *Type - numberOrBigIntType *Type - templateConstraintType *Type - numericStringType *Type - uniqueLiteralType *Type uniqueLiteralMapper *TypeMapper reliabilityFlags RelationComparisonResult reportUnreliableMapper *TypeMapper reportUnmeasurableMapper *TypeMapper restrictiveMapper *TypeMapper permissiveMapper *TypeMapper - emptyObjectType *Type - emptyJsxObjectType *Type - emptyFreshJsxObjectType *Type - emptyTypeLiteralType *Type - unknownEmptyObjectType *Type - unknownUnionType *Type - emptyGenericType *Type - anyFunctionType *Type - noConstraintType *Type - circularConstraintType *Type - resolvingDefaultType *Type - markerSuperType *Type - markerSubType *Type - markerOtherType *Type - markerSuperTypeForCheck *Type - markerSubTypeForCheck *Type - noTypePredicate *TypePredicate - anySignature *Signature - unknownSignature *Signature - resolvingSignature *Signature - silentNeverSignature *Signature - cachedArgumentsReferenced map[*ast.Node]bool - enumNumberIndexInfo *IndexInfo - anyBaseTypeIndexInfo *IndexInfo - patternAmbientModules []*ast.PatternAmbientModule - patternAmbientModuleAugmentations ast.SymbolTable - patternAmbientModuleAugmentationTargets ast.SymbolTable - moduleImportAttributesTypes map[*ast.Symbol]*Type - globalObjectType *Type - globalFunctionType *Type - globalCallableFunctionType *Type - globalNewableFunctionType *Type - globalArrayType *Type - globalReadonlyArrayType *Type - globalStringType *Type - globalNumberType *Type - globalBooleanType *Type - globalRegExpType *Type - globalThisType *Type - anyArrayType *Type - autoArrayType *Type - anyReadonlyArrayType *Type - deferredGlobalImportMetaExpressionType *Type - contextualBindingPatterns []*ast.Node - emptyStringType *Type - zeroType *Type - zeroBigIntType *Type - typeofType *Type - typeResolutions []TypeResolution - resolutionStart int + resolving resolvingTable // Index in resolutions of the outermost computation of each key in progress + typeResolutionTop int // 1-based index in resolutions of the innermost resolution, or 0 + resolutionStart int // Index in resolutions below which resolutions are not searched for cycles + visibleStart int // Index in resolutions below which nothing in progress is visible; see yieldCycle + cycleYields []cycleYield // Canonical recomputations in progress; see yieldCycle + circularityStart int // 1-based index in resolutions of the outermost cycle in progress, or 0; see memo.go + currentNodeErrors []*currentNodeError // Errors reported at the current node while collecting; see startCurrentNodeErrors + currentNodeErrorCollectors int // Number of computations collecting currentNodeErrors + currentNodeErrorsCyclic bool // Whether a cycle was observed while collecting currentNodeErrors; see endCurrentNodeErrors + discardLog []discardEntry // Restores what was cached while anything may be discarded; see "Discard log" in memo.go + discardLogFloor int // Length of the discard log kept for measurements hidden by a canonical variance remeasurement; see trimDiscardLog + circularityMark int // Length of discard log when the cycle in progress was detected + innerCycles []innerCycle // Cycles detected inside the one in progress; see extendCircularity + flowDepthFailures map[FlowLoopKey]int // Largest depth budget known to be too small for a flow walk from a node; see getTypeAtFlowNode + observedHead int32 // 1 + index in resolutions of the lowest head of a cycle observed by the innermost type resolution in progress, or 0 + cycleParticipants []*memoHeader // Computations that observed a cycle in progress + effectsMarkDepth int // 1 + resolution index of the innermost effects mark that may be discarded, or 0 varianceStack []VarianceStackEntry - callResolutionStack []*ast.Node - apparentArgumentCount *int + varianceCycleRoot int // 1 + index in varianceStack of the outermost measurement re-entered in progress, or 0; see getRecursiveVariances + heldEffects []func(c *Checker) // See holdEffect + heldEffectsFloor int // Number of held effects kept for measurements hidden by a canonical variance remeasurement; see trimDiscardLog + varianceSuperseded bool // The measurement at the bottom of varianceStack is certain to be discarded; see getRecursiveVariances + varianceProvisional []*ast.Symbol // Types measured in a circularity with a measurement in progress; see isGuessedVariance + flushBuf []*memoState + resumeBuf []int + deferredAttach []deferredAttachment // See attachState + recordingFromCheck bool // A query begun in a check is in progress; see recordFromCheck + request *editorRequest // The editor request being answered, if any; see runEditorRequest lastGetCombinedNodeFlagsNode *ast.Node lastGetCombinedNodeFlagsResult ast.NodeFlags lastGetCombinedModifierFlagsNode *ast.Node lastGetCombinedModifierFlagsResult ast.ModifierFlags freeinferenceState *InferenceState freeFlowState *FlowState - flowLoopCache map[FlowLoopKey]*Type flowLoopStack []FlowLoopInfo + contextualParameterAssignments []contextualParameterAssignment + parametersAssigning []*ast.Symbol + signaturesResolving []*SignatureLinks // Calls whose resolution is in progress + visibleSignatures int // Index in signaturesResolving below which nothing is visible; see yieldCycle sharedFlows []SharedFlow antecedentTypes []*Type - flowAnalysisDisabled bool flowInvocationCount int - flowTypeCache map[*ast.Node]*Type + flowTypeCache map[*ast.Node]*Type // Types of expressions within the innermost loop analysis lastFlowNode *ast.FlowNode lastFlowNodeReachable bool - flowNodeReachable map[*ast.FlowNode]bool - flowNodePostSuper map[*ast.FlowNode]bool - renamedBindingElementsInTypes []*ast.Node contextualInfos []ContextualInfo inferenceContextInfos []InferenceContextInfo - awaitedTypeStack []*Type reverseMappedSourceStack []*Type reverseMappedTargetStack []*Type resolvingObjectTypeStack []ResolvingObjectType reverseExpandingFlags ExpandingFlags + reverseMappedStart int32 freeRelater *Relater - subtypeRelation *Relation - strictSubtypeRelation *Relation - assignableRelation *Relation - comparableRelation *Relation - identityRelation *Relation - enumRelation map[EnumRelationKey]RelationComparisonResult getGlobalESSymbolType func() *Type getGlobalBigIntType func() *Type getGlobalImportMetaType func() *Type @@ -928,38 +814,276 @@ type Checker struct { isStringIndexSignatureOnlyType func(*Type) bool markNodeAssignments func(*ast.Node) bool compareTypesAssignable TypeComparer - emitResolverLinks EmitResolverLinks - _jsxNamespace string - _jsxFactoryEntity *ast.Node - skipDirectInferenceNodes collections.Set[*ast.Node] ctx context.Context - packagesMap map[string]bool activeMappers []*TypeMapper - activeTypeMappersCaches []clearableMap[*Type] - ambientModulesOnce sync.Once - ambientModules []*ast.Symbol + activeTypeMappersCaches []clearableMap[activeMapperCacheEntry] withinUnreachableCode bool - reportedUnreachableNodes collections.Set[*ast.Node] - nonExistentProperties collections.Set[NonExistentPropertyKey] - deferredDiagnosticCallbacks []func() typeToStringNodebuilder *NodeBuilder - - mu sync.Mutex - tracer *Tracer // Optional tracer for trace events and type recording (for --generateTrace) + tracer *Tracer // Optional tracer for trace events and type recording (for --generateTrace) + checking bool // Whether side effects such as diagnostics are applied; see memo.go + markingForEmit bool // Whether emit is marking the references of a file; see writesMarks + observingMemos bool // See syncObserving + instantiationCount uint32 // Instantiations since the start of the current statement, expression or outermost computation; see "Instantiation limits" + memoTop int // 1 + index in resolutions of the innermost computation recording effects, or 0; see memo.go +} + +// memoStore holds the memoized state of a checker: interned types, links, +// relation caches, and collected diagnostics. Every checker sharing a store +// observes the same results. +type memoStore struct { + root *Checker // The checker that created this store; owns type back-pointers. + id uint32 + program Program + compilerOptions *core.CompilerOptions + files []*ast.SourceFile + fileIndexMap map[*ast.SourceFile]int + TypeCount uint32 + memberLayoutCount uint32 + SymbolCount uint32 + SignatureCount uint32 + TotalInstantiationCount uint32 + tooDeepInstantiations map[memoKey]struct{} // See "Instantiation limits" + languageVersion core.ScriptTarget + moduleKind core.ModuleKind + moduleResolutionKind core.ModuleResolutionKind + legacyDecorators bool + emitStandardClassFields bool + strictNullChecks bool + strictFunctionTypes bool + strictBindCallApply bool + strictPropertyInitialization bool + strictBuiltinIteratorReturn bool + noImplicitAny bool + noImplicitThis bool + useUnknownInCatchVariables bool + exactOptionalPropertyTypes bool + canCollectSymbolAliasAccessibilityData bool + arrayVariances []VarianceFlags + globals ast.SymbolTable + globalIDs map[globalKey]globalID + globalTypes []memo[resolvedGlobal[*Type]] // Indexed by globalID + globalSymbols []memo[resolvedGlobal[*ast.Symbol]] // Indexed by globalID + stringLiteralTypes internMap[string, *Type] + numberLiteralTypes internMap[jsnum.Number, *Type] + nanType *Type + bigintLiteralTypes internMap[jsnum.PseudoBigInt, *Type] + enumLiteralTypes internMap[EnumLiteralKey, *Type] + enumNaNLiteralTypes internMap[*ast.Symbol, *Type] + indexedAccessTypes internMap[CacheHashKey, *Type] + templateLiteralTypes internMap[CacheHashKey, *Type] + stringMappingTypes internMap[StringMappingKey, *Type] + uniqueESSymbolTypes internMap[*ast.Symbol, *Type] + thisExpandos internMap[*ast.Symbol, thisExpando] + subtypeReductionCache memoMap[CacheHashKey, []*Type] + cachedTypes memoMap[CachedTypeKey, *Type] + cachedSignatures memoMap[CachedSignatureKey, *Signature] + undefinedProperties memoMap[*ast.Symbol, *ast.Symbol] + narrowedTypes memoMap[NarrowedTypeKey, *Type] + assignmentReducedTypes memoMap[AssignmentReducedKey, *Type] + discriminatedContextualTypes memoMap[DiscriminatedContextualTypeKey, *Type] + instantiationExpressionTypes internMap[InstantiationExpressionKey, *instantiationExpressionEntry] + substitutionTypes internMap[SubstitutionTypeKey, *Type] + reverseMappedCache memoMap[ReverseMappedTypeKey, *Type] + reverseHomomorphicMappedCache memoMap[ReverseMappedTypeKey, *Type] + iterationTypesCache memoMap[IterationTypesKey, IterationTypes] + memberLayoutCache memoMap[CacheHashKey, *MemberLayout] + constructorOrFunctionChecked memoSet[*ast.Symbol] + typeParametersChecked memoSet[*ast.Symbol] + indexSignaturesChecked memoSet[*ast.Symbol] + interfaceChecked memoSet[*ast.Symbol] + enumChecked memoSet[*ast.Symbol] + moduleExportsChecked memoSet[*ast.Symbol] + assignmentsMarked memoSet[*ast.Node] // Functions and source files whose assignments have been marked + undefinedSymbol *ast.Symbol + argumentsSymbol *ast.Symbol + requireSymbol *ast.Symbol + unknownSymbol *ast.Symbol + unresolvedSymbols internMap[string, *ast.Symbol] + errorTypes internMap[CacheHashKey, *Type] + globalThisSymbol *ast.Symbol + symbolTableAliasCache internMap[symbolTableID, []*ast.Symbol] + classExpressionNameTables internMap[ast.NodeId, ast.SymbolTable] + tupleTypes internMap[CacheHashKey, *Type] + unionTypes internMap[CacheHashKey, *Type] + unionOfUnionTypes memoMap[UnionOfUnionKey, *Type] + intersectionTypes memoMap[CacheHashKey, *Type] + objectLiteralTypes internMap[*ast.Node, []objectLiteralType] + spreadTypes memoMap[CacheHashKey, *Type] + objectContentTypes internMap[CacheHashKey, *Type] + spreadSymbols memoMap[spreadSymbolKey, *ast.Symbol] + symbolsWithType internMap[symbolWithTypeKey, *ast.Symbol] + paddedProperties internMap[symbolWithTypeKey, *ast.Symbol] + bindingPatternTypes internMap[CacheHashKey, *Type] + intersectionContentTypes internMap[CacheHashKey, *Type] + propertiesTypes memoMap[PropertiesTypesKey, *Type] + diagnostics ast.DiagnosticsCollection + suggestionDiagnostics ast.DiagnosticsCollection + mergedSymbols symbolLinkStore[*ast.Symbol] + lateMergedSymbols memoMap[*ast.Symbol, *ast.Symbol] + // getLateBindableKinds of the merged symbol of a parent of members, with + // lateBindableKnown set once known; see getLateMergedSymbol. + parentLateBindableKinds symbolLinkStore[uint8] + // mergesFrozen is set once global merging is done; mergedSymbols is + // immutable from then on. + mergesFrozen bool + mergedExportsChecked memoSet[*ast.Symbol] + nodeLinks core.LinkStore[*ast.Node, NodeLinks] + signatureLinks nodeLinkStore[SignatureLinks] + symbolNodeLinks nodeLinkStore[SymbolNodeLinks] + typeNodeLinks nodeLinkStore[TypeNodeLinks] + enumMemberLinks core.LinkStore[*ast.Node, EnumMemberLinks] + arrayLiteralLinks core.LinkStore[*ast.Node, ArrayLiteralLinks] + switchStatementLinks core.LinkStore[*ast.Node, SwitchStatementLinks] + jsxElementLinks core.LinkStore[*ast.Node, JsxElementLinks] + computedNameLinks core.LinkStore[*ast.Node, ComputedNameNodeLinks] + symbolReferenceLinks core.LinkStore[*ast.Symbol, SymbolReferenceLinks] + valueSymbolLinks symbolLinkStore[ValueSymbolLinks] + mappedSymbolLinks core.LinkStore[*ast.Symbol, MappedSymbolLinks] + deferredSymbolLinks core.LinkStore[*ast.Symbol, DeferredSymbolLinks] + aliasSymbolLinks core.LinkStore[*ast.Symbol, AliasSymbolLinks] + moduleSymbolLinks core.LinkStore[*ast.Symbol, ModuleSymbolLinks] + lateBoundLinks core.LinkStore[*ast.Symbol, LateBoundLinks] + exportTypeLinks core.LinkStore[*ast.Symbol, ExportTypeLinks] + membersAndExportsLinks core.LinkStore[*ast.Symbol, MembersAndExportsLinks] + typeAliasLinks core.LinkStore[*ast.Symbol, TypeAliasLinks] + declaredTypeLinks core.LinkStore[*ast.Symbol, DeclaredTypeLinks] + spreadLinks core.LinkStore[*ast.Symbol, SpreadLinks] + varianceLinks symbolLinkStore[VarianceLinks] + ReverseMappedSymbolLinks core.LinkStore[*ast.Symbol, ReverseMappedSymbolLinks] + markedAssignmentSymbolLinks core.LinkStore[*ast.Symbol, MarkedAssignmentSymbolLinks] + importedContainingModules memoMap[symbolFileKey, []*ast.Symbol] // Modules imported by a file that export a symbol + extendedContainers memoMap[*ast.Symbol, []*ast.Symbol] // Containers (other than the parent) which a symbol is aliased in + accessibleChains memoMap[accessibleChainCacheKey, []*ast.Symbol] // Accessible symbol chains by location + externalModuleContainers memo[*externalModuleContainerIndex] + sourceFileLinks core.LinkStore[*ast.SourceFile, SourceFileLinks] + patternForType internMap[*Type, *ast.Node] + contextFreeTypes memoMap[*ast.Node, *Type] + anyType *Type + autoType *Type + wildcardType *Type + blockedStringType *Type + errorType *Type + unresolvedType *Type + nonInferrableAnyType *Type + intrinsicMarkerType *Type + unknownType *Type + undefinedType *Type + undefinedWideningType *Type + missingType *Type + undefinedOrMissingType *Type + optionalType *Type + nullType *Type + nullWideningType *Type + stringType *Type + numberType *Type + bigintType *Type + regularFalseType *Type + falseType *Type + regularTrueType *Type + trueType *Type + booleanType *Type + esSymbolType *Type + voidType *Type + neverType *Type + silentNeverType *Type + implicitNeverType *Type + unreachableNeverType *Type + nonPrimitiveType *Type + stringOrNumberType *Type + stringNumberSymbolType *Type + numberOrBigIntType *Type + templateConstraintType *Type + numericStringType *Type + uniqueLiteralType *Type + emptyObjectType *Type + emptyJsxObjectType *Type + emptyFreshJsxObjectType *Type + emptyTypeLiteralType *Type + unknownEmptyObjectType *Type + unknownUnionType *Type + emptyGenericType *Type + anyFunctionType *Type + noConstraintType *Type + circularConstraintType *Type + resolvingDefaultType *Type + markerSuperType *Type + markerSubType *Type + markerOtherType *Type + markerSuperTypeForCheck *Type + markerSubTypeForCheck *Type + noTypePredicate *TypePredicate + anySignature *Signature + unknownSignature *Signature + resolvingSignature *Signature + silentNeverSignature *Signature + cachedArgumentsReferenced memoMap[*ast.Node, bool] + enumNumberIndexInfo *IndexInfo + anyBaseTypeIndexInfo *IndexInfo + patternAmbientModules []*ast.PatternAmbientModule + patternAmbientModuleAugmentations ast.SymbolTable + patternAmbientModuleAugmentationTargets ast.SymbolTable + moduleImportAttributesTypes memoMap[*ast.Symbol, *Type] + globalObjectType *Type + globalFunctionType *Type + globalCallableFunctionType *Type + globalNewableFunctionType *Type + globalArrayType *Type + globalReadonlyArrayType *Type + globalStringType *Type + globalNumberType *Type + globalBooleanType *Type + globalRegExpType *Type + globalThisType *Type + anyArrayType *Type + autoArrayType *Type + anyReadonlyArrayType *Type + deferredGlobalImportMetaExpressionType memo[*Type] + emptyStringType *Type + zeroType *Type + zeroBigIntType *Type + typeofType *Type + flowExpressionTypes memoMap[*ast.Node, *Type] + flowLoopCache internMap[FlowLoopKey, *flowLoopCacheEntry] + flowNodeReachable memoMap[*ast.FlowNode, bool] + flowNodePostSuper memoMap[*ast.FlowNode, bool] + subtypeRelation *Relation + strictSubtypeRelation *Relation + assignableRelation *Relation + comparableRelation *Relation + identityRelation *Relation + enumRelation memoMap[EnumRelationKey, RelationComparisonResult] + emitResolverLinks EmitResolverLinks + _jsxNamespace string + _jsxFactoryEntity *ast.Node + packagesMap map[string]bool + ambientModulesOnce sync.Once + ambientModules []*ast.Symbol + reportedUnreachableNodes memoSet[*ast.Node] + unreachableRuns memoMap[*ast.Node, map[*ast.Node]unreachableRun] + checkedRegularExpressions memoSet[*ast.Node] + nonExistentPropertyNodes collections.Set[*ast.Node] // Property names reported as nonexistent + deferredDiagnosticCallbacks []func(c *Checker) + memoStates map[memoKey]*memoState // Memo state of results computed by queries; see memo.go + stateFilter stateKeyFilter // Memo keys that may have a memo state; see memoState + errorFilter errorKeyFilter // Memo keys that may have reports; see observeMemo + memoPendingCount int // Number of memoStates with unreplayed effects + memoErrorStates int // Number of memoStates with reports; see setReported + + mu sync.Mutex } func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { program.BindSourceFiles() - c := &Checker{} + c := &Checker{memoStore: &memoStore{}, checking: true} + c.initResolutions() + c.root = c c.id = nextCheckerID.Add(1) c.tracer = tracer c.program = program c.compilerOptions = program.Options() c.files = program.SourceFiles() c.fileIndexMap = createFileIndexMap(c.files) - c.compareSymbols = c.compareSymbolsWorker // Closure optimization - c.compareSymbolChains = c.compareSymbolChainsWorker // Closure optimization c.languageVersion = c.compilerOptions.GetEmitScriptTarget() c.moduleKind = c.compilerOptions.GetEmitModuleKind() c.moduleResolutionKind = c.compilerOptions.GetModuleResolutionKind() @@ -977,49 +1101,14 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.canCollectSymbolAliasAccessibilityData = c.compilerOptions.VerbatimModuleSyntax.IsFalseOrUnknown() c.arrayVariances = []VarianceFlags{VarianceFlagsCovariant} c.globals = ast.NewSymbolTableWithCapacity(countGlobalSymbols(c.files)) - c.evaluate = evaluator.NewEvaluator(c.evaluateEntity, ast.OEKParentheses) - c.stringLiteralTypes = make(map[string]*Type) - c.numberLiteralTypes = make(map[jsnum.Number]*Type) - c.bigintLiteralTypes = make(map[jsnum.PseudoBigInt]*Type) - c.enumLiteralTypes = make(map[EnumLiteralKey]*Type) - c.enumNaNLiteralTypes = make(map[*ast.Symbol]*Type) - c.indexedAccessTypes = make(map[CacheHashKey]*Type) - c.templateLiteralTypes = make(map[CacheHashKey]*Type) - c.stringMappingTypes = make(map[StringMappingKey]*Type) - c.uniqueESSymbolTypes = make(map[*ast.Symbol]*Type) - c.thisExpandoKinds = make(map[*ast.Symbol]thisAssignmentDeclarationKind) - c.thisExpandoLocations = make(map[*ast.Symbol]*ast.Node) - c.subtypeReductionCache = make(map[CacheHashKey][]*Type) - c.cachedTypes = make(map[CachedTypeKey]*Type) - c.cachedSignatures = make(map[CachedSignatureKey]*Signature) - c.undefinedProperties = make(map[*ast.Symbol]*ast.Symbol) - c.narrowedTypes = make(map[NarrowedTypeKey]*Type) - c.assignmentReducedTypes = make(map[AssignmentReducedKey]*Type) - c.discriminatedContextualTypes = make(map[DiscriminatedContextualTypeKey]*Type) - c.instantiationExpressionTypes = make(map[InstantiationExpressionKey]*Type) - c.substitutionTypes = make(map[SubstitutionTypeKey]*Type) - c.reverseMappedCache = make(map[ReverseMappedTypeKey]*Type) - c.reverseHomomorphicMappedCache = make(map[ReverseMappedTypeKey]*Type) - c.iterationTypesCache = make(map[IterationTypesKey]IterationTypes) c.undefinedSymbol = c.newSymbol(ast.SymbolFlagsProperty, "undefined") c.argumentsSymbol = c.newSymbol(ast.SymbolFlagsProperty, "arguments") c.requireSymbol = c.newSymbol(ast.SymbolFlagsProperty, "require") c.unknownSymbol = c.newSymbol(ast.SymbolFlagsProperty, "unknown") - c.unresolvedSymbols = make(map[string]*ast.Symbol) - c.errorTypes = make(map[CacheHashKey]*Type) - c.moduleSymbols = make(map[*ast.Node]*ast.Symbol) c.globalThisSymbol = c.newSymbolEx(ast.SymbolFlagsModule, "globalThis", ast.CheckFlagsReadonly) c.globalThisSymbol.SetExports(c.globals, &c.symbolExtraArena) c.globals.Set(c.globalThisSymbol.Name(), c.globalThisSymbol) - c.resolveName = c.createNameResolver().Resolve - c.resolveNameForSymbolSuggestion = c.createNameResolverForSuggestion().Resolve - c.tupleTypes = make(map[CacheHashKey]*Type) - c.unionTypes = make(map[CacheHashKey]*Type) - c.unionOfUnionTypes = make(map[UnionOfUnionKey]*Type) - c.intersectionTypes = make(map[CacheHashKey]*Type) - c.propertiesTypes = make(map[PropertiesTypesKey]*Type) - c.patternForType = make(map[*Type]*ast.Node) - c.contextFreeTypes = make(map[*ast.Node]*Type) + c.initCheckerState() c.anyType = c.newIntrinsicType(TypeFlagsAny, "any") c.autoType = c.newIntrinsicTypeEx(TypeFlagsAny, "any", ObjectFlagsNonInferrableType) c.wildcardType = c.newIntrinsicType(TypeFlagsAny, "any") @@ -1061,11 +1150,6 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.numericStringType = c.getTemplateLiteralType([]string{"", ""}, []*Type{c.numberType}) // The `${number}` type c.templateConstraintType = c.getUnionType([]*Type{c.stringType, c.numberType, c.booleanType, c.bigintType, c.nullType, c.undefinedType}) c.uniqueLiteralType = c.newIntrinsicType(TypeFlagsNever, "never") // Special `never` flagged by union reduction to behave as a literal - c.uniqueLiteralMapper = newFunctionTypeMapper(c.getUniqueLiteralTypeForTypeParameter) - c.reportUnreliableMapper = newFunctionTypeMapper(c.reportUnreliableWorker) - c.reportUnmeasurableMapper = newFunctionTypeMapper(c.reportUnmeasurableWorker) - c.restrictiveMapper = newFunctionTypeMapper(c.restrictiveMapperWorker) - c.permissiveMapper = newFunctionTypeMapper(c.permissiveMapperWorker) c.emptyObjectType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) c.emptyJsxObjectType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) c.emptyFreshJsxObjectType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) @@ -1073,7 +1157,6 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.unknownEmptyObjectType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) c.unknownUnionType = c.createUnknownUnionType() c.emptyGenericType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) - c.emptyGenericType.AsObjectType().instantiations = make(map[CacheHashKey]*Type) c.anyFunctionType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) c.anyFunctionType.objectFlags |= ObjectFlagsNonInferrableType c.noConstraintType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) @@ -1081,33 +1164,53 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.resolvingDefaultType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) c.markerSuperType = c.newTypeParameter(nil) c.markerSubType = c.newTypeParameter(nil) - c.markerSubType.AsTypeParameter().constraint = c.markerSuperType + c.markerSubType.AsTypeParameter().constraint.intern(c.markerSuperType) c.markerOtherType = c.newTypeParameter(nil) c.markerSuperTypeForCheck = c.newTypeParameter(nil) c.markerSubTypeForCheck = c.newTypeParameter(nil) - c.markerSubTypeForCheck.AsTypeParameter().constraint = c.markerSuperTypeForCheck + c.markerSubTypeForCheck.AsTypeParameter().constraint.intern(c.markerSuperTypeForCheck) c.noTypePredicate = &TypePredicate{kind: TypePredicateKindIdentifier, parameterIndex: 0, parameterName: "<>", t: c.anyType} c.anySignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.anyType, nil, 0) c.unknownSignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.errorType, nil, 0) c.resolvingSignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.anyType, nil, 0) c.silentNeverSignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.silentNeverType, nil, 0) - c.cachedArgumentsReferenced = make(map[*ast.Node]bool) c.enumNumberIndexInfo = &IndexInfo{keyType: c.numberType, valueType: c.stringType, isReadonly: true} c.anyBaseTypeIndexInfo = &IndexInfo{keyType: c.stringType, valueType: c.anyType, isReadonly: false} c.emptyStringType = c.getStringLiteralType("") c.zeroType = c.getNumberLiteralType(0) c.zeroBigIntType = c.getBigIntLiteralType(jsnum.PseudoBigInt{}) c.typeofType = c.getUnionType(core.Map(slices.Sorted(maps.Keys(typeofNEFacts)), c.getStringLiteralType)) - c.flowLoopCache = make(map[FlowLoopKey]*Type) - c.flowNodeReachable = make(map[*ast.FlowNode]bool) - c.flowNodePostSuper = make(map[*ast.FlowNode]bool) c.subtypeRelation = &Relation{} c.strictSubtypeRelation = &Relation{} c.assignableRelation = &Relation{} c.comparableRelation = &Relation{} c.identityRelation = &Relation{} - c.enumRelation = make(map[EnumRelationKey]RelationComparisonResult) - c.moduleImportAttributesTypes = make(map[*ast.Symbol]*Type) + for _, r := range []*Relation{c.subtypeRelation, c.strictSubtypeRelation, c.assignableRelation, c.comparableRelation, c.identityRelation} { + r.results.setKeyBits(relationKeyBits) + } + // Re-entering the type of an expression computes it again, like + // re-entering the cell of checkExpressionCachedEx. + c.flowExpressionTypes.setReentry(reentryPartial) + c.initializeChecker() + c.mergesFrozen = true + c.checking = false + c.syncObserving() + return c, &c.mu +} + +// initCheckerState initializes the per-checker state of c, including closures +// that must be bound to this checker rather than the store. +func (c *Checker) initCheckerState() { + c.compareSymbols = c.compareSymbolsWorker // Closure optimization + c.compareSymbolChains = c.compareSymbolChainsWorker // Closure optimization + c.evaluate = evaluator.NewEvaluator(c.evaluateEntity, ast.OEKParentheses) + c.resolveName = c.createNameResolver().Resolve + c.resolveNameForSymbolSuggestion = c.createNameResolverForSuggestion().Resolve + c.uniqueLiteralMapper = newFunctionTypeMapper(c.getUniqueLiteralTypeForTypeParameter) + c.reportUnreliableMapper = newFunctionTypeMapper(c.reportUnreliableWorker) + c.reportUnmeasurableMapper = newFunctionTypeMapper(c.reportUnmeasurableWorker) + c.restrictiveMapper = newFunctionTypeMapper(c.restrictiveMapperWorker) + c.permissiveMapper = newFunctionTypeMapper(c.permissiveMapperWorker) c.getGlobalESSymbolType = c.getGlobalTypeResolver("Symbol", 0 /*arity*/, false /*reportErrors*/) c.getGlobalBigIntType = c.getGlobalTypeResolver("BigInt", 0 /*arity*/, false /*reportErrors*/) c.getGlobalImportMetaType = c.getGlobalTypeResolver("ImportMeta", 0 /*arity*/, true /*reportErrors*/) @@ -1161,8 +1264,24 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.getGlobalClassFieldDecoratorContextType = c.getGlobalTypeResolver("ClassFieldDecoratorContext", 2 /*arity*/, true /*reportErrors*/) c.initializeClosures() c.initializeIterationResolvers() - c.initializeChecker() - return c, &c.mu + // Memos are identified by their addresses, so the cells are allocated + // once all resolvers have their IDs. + if c.globalTypes == nil { + c.globalTypes = make([]memo[resolvedGlobal[*Type]], len(c.globalIDs)) + c.globalSymbols = make([]memo[resolvedGlobal[*ast.Symbol]], len(c.globalIDs)) + } + debug.Assert(len(c.globalTypes) == len(c.globalIDs), "a checker sharing a store resolves a global the store has no cell for") +} + +// Clone returns a new checker sharing c's store. The clone observes and +// contributes to the same memoized state, but has its own resolution stacks. +// Checkers sharing a store must not be used concurrently; acquire the store's +// lock (returned by NewChecker) before use. +func (c *Checker) Clone() *Checker { + clone := &Checker{memoStore: c.memoStore, tracer: c.tracer} + clone.initResolutions() + clone.initCheckerState() + return clone } func createFileIndexMap(files []*ast.SourceFile) map[*ast.SourceFile]int { @@ -1197,39 +1316,102 @@ func (c *Checker) reportUnmeasurableWorker(t *Type) *Type { return t } +// globalKey identifies the resolution of a global by name. Resolutions are +// cached in the store, so all checkers share them. +type globalKey struct { + kind globalKind + name string + arity int + reportErrors bool +} + +// globalID is the small integer standing for a globalKey in the store, so +// that resolving a global hashes an integer rather than a name. Resolvers are +// all created as a checker is initialized, so the first checker of a store +// assigns every ID. +type globalID uint32 + +func (c *Checker) getGlobalID(key globalKey) globalID { + if id, ok := c.globalIDs[key]; ok { + return id + } + if c.globalIDs == nil { + c.globalIDs = make(map[globalKey]globalID) + } + id := globalID(len(c.globalIDs)) + c.globalIDs[key] = id + return id +} + +type globalKind uint8 + +const ( + globalKindType globalKind = iota + globalKindTypeAlias + globalKindValueSymbol + globalKindTypeSymbol +) + // Resolve to the global class or interface by the given name and arity, or emptyObjectType/emptyGenericType otherwise func (c *Checker) getGlobalTypeResolver(name string, arity int, reportErrors bool) func() *Type { - return core.Memoize(func() *Type { - return c.getGlobalType(name, arity, reportErrors) - }) + key := c.getGlobalID(globalKey{globalKindType, name, arity, reportErrors}) + return func() *Type { + m := &c.globalTypes[key] + if r := m.cached(c); r.resolved { + return r.value + } + return c.memoCompute(m, func() resolvedGlobal[*Type] { + return resolvedGlobal[*Type]{c.getGlobalType(name, arity, reportErrors), true} + }).value + } +} + +// resolvedGlobal is the result of resolving a global, which may be nil. +type resolvedGlobal[T any] struct { + value T + resolved bool } // Resolve to the global type alias symbol by the given name and arity, or nil otherwise func (c *Checker) getGlobalTypeAliasResolver(name string, arity int, reportErrors bool) func() *ast.Symbol { - return core.Memoize(func() *ast.Symbol { + return c.getGlobalSymbolResolver(globalKey{globalKindTypeAlias, name, arity, reportErrors}, func() *ast.Symbol { return c.getGlobalTypeAliasSymbol(name, arity, reportErrors) }) } // Resolve to the global value symbol by the given name, or nil otherwise func (c *Checker) getGlobalValueSymbolResolver(name string, reportErrors bool) func() *ast.Symbol { - return core.Memoize(func() *ast.Symbol { + return c.getGlobalSymbolResolver(globalKey{globalKindValueSymbol, name, 0, reportErrors}, func() *ast.Symbol { return c.getGlobalSymbol(name, ast.SymbolFlagsValue, core.IfElse(reportErrors, diagnostics.Cannot_find_global_value_0, nil)) }) } func (c *Checker) getGlobalTypeSymbolResolver(name string, reportErrors bool) func() *ast.Symbol { - return core.Memoize(func() *ast.Symbol { + return c.getGlobalSymbolResolver(globalKey{globalKindTypeSymbol, name, 0, reportErrors}, func() *ast.Symbol { return c.getGlobalSymbol(name, ast.SymbolFlagsType, core.IfElse(reportErrors, diagnostics.Cannot_find_global_type_0, nil)) }) } +func (c *Checker) getGlobalSymbolResolver(k globalKey, resolve func() *ast.Symbol) func() *ast.Symbol { + key := c.getGlobalID(k) + return func() *ast.Symbol { + m := &c.globalSymbols[key] + if r := m.cached(c); r.resolved { + return r.value + } + return c.memoCompute(m, func() resolvedGlobal[*ast.Symbol] { + return resolvedGlobal[*ast.Symbol]{resolve(), true} + }).value + } +} + func (c *Checker) getGlobalTypesResolver(names []string, arity int, reportErrors bool) func() []*Type { - return core.Memoize(func() []*Type { - return core.Map(names, func(name string) *Type { - return c.getGlobalType(name, arity, reportErrors) - }) + resolvers := core.Map(names, func(name string) func() *Type { + return c.getGlobalTypeResolver(name, arity, reportErrors) }) + return func() []*Type { + return core.Map(resolvers, func(resolve func() *Type) *Type { return resolve() }) + } } func (c *Checker) getGlobalTypeAliasSymbol(name string, arity int, reportErrors bool) *ast.Symbol { @@ -1239,7 +1421,7 @@ func (c *Checker) getGlobalTypeAliasSymbol(name string, arity int, reportErrors } // Resolve the declared type of the symbol. This resolves type parameters for the type alias so that we can check arity. c.getDeclaredTypeOfSymbol(symbol) - if len(c.typeAliasLinks.Get(symbol).typeParameters) != arity { + if len(c.getTypeParametersOfTypeAlias(symbol)) != arity { if reportErrors { decl := core.Find(symbol.Declarations(), ast.IsTypeAliasDeclaration) c.error(decl, diagnostics.Global_type_0_must_have_1_type_parameter_s, ast.SymbolName(symbol), arity) @@ -1253,6 +1435,12 @@ func (c *Checker) GetTypeAliasTypeParameters(symbol *ast.Symbol) []*Type { if symbol.Flags()&ast.SymbolFlagsTypeAlias == 0 { panic("Attempted to fetch type alias parameters for non-type-alias symbol") } + return c.getTypeParametersOfTypeAlias(symbol) +} + +// getTypeParametersOfTypeAlias returns the type parameters of a type alias, +// which are resolved along with its declared type. +func (c *Checker) getTypeParametersOfTypeAlias(symbol *ast.Symbol) []*Type { c.getDeclaredTypeOfSymbol(symbol) return c.typeAliasLinks.Get(symbol).typeParameters } @@ -1392,10 +1580,10 @@ func (c *Checker) initializeChecker() { } } c.addUndefinedToGlobalsOrErrorOnRedeclaration() - c.valueSymbolLinks.Get(c.undefinedSymbol).resolvedType = c.undefinedWideningType - c.valueSymbolLinks.Get(c.argumentsSymbol).resolvedType = c.getGlobalType("IArguments", 0 /*arity*/, true /*reportErrors*/) - c.valueSymbolLinks.Get(c.unknownSymbol).resolvedType = c.errorType - c.valueSymbolLinks.Get(c.globalThisSymbol).resolvedType = c.newObjectType(ObjectFlagsAnonymous, c.globalThisSymbol) + c.valueSymbolLinks.Get(c.undefinedSymbol).resolvedType.set(c, c.undefinedWideningType) + c.valueSymbolLinks.Get(c.argumentsSymbol).resolvedType.set(c, c.getGlobalType("IArguments", 0 /*arity*/, true /*reportErrors*/)) + c.valueSymbolLinks.Get(c.unknownSymbol).resolvedType.set(c, c.errorType) + c.valueSymbolLinks.Get(c.globalThisSymbol).resolvedType.set(c, c.newObjectType(ObjectFlagsAnonymous, c.globalThisSymbol)) // Initialize special types c.globalArrayType = c.getGlobalType("Array", 1 /*arity*/, true /*reportErrors*/) c.globalObjectType = c.getGlobalType("Object", 0 /*arity*/, true /*reportErrors*/) @@ -1578,9 +1766,25 @@ func (c *Checker) createNameResolverForSuggestion() *binder.NameResolver { } func (c *Checker) symbolReferenced(symbol *ast.Symbol, meaning ast.SymbolFlags) { + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.symbolReferenced(symbol, meaning) }) + return + } c.symbolReferenceLinks.Get(symbol).referenceKinds |= meaning } +// writesMarks reports whether marks that checking accumulates for later +// checks and emit to read, such as which symbols are referenced, are written +// now: when checking, including while a check records what it computes in a +// cycle, which may discard the results but not that their source was +// reached, or when emit marks the references of a file itself. Otherwise a +// computation answering a query records them as an effect, so that they are +// written only once checking reaches its result, as if checking had computed +// it, and a query, such as printing a type, writes none of its own. +func (c *Checker) writesMarks() bool { + return c.checking || c.recordingFromCheck || c.markingForEmit +} + func (c *Checker) getRequiresScopeChangeCache(node *ast.Node) core.Tristate { return c.nodeLinks.Get(node).declarationRequiresScopeChange } @@ -1643,6 +1847,17 @@ func (c *Checker) checkAndReportErrorForMissingPrefix(errorLocation *ast.Node, n } func (c *Checker) onFailedToResolveSymbol(errorLocation *ast.Node, name string, meaning ast.SymbolFlags, nameNotFoundMessage *diagnostics.Message) { + // Explaining the failure looks up other symbols, for example to suggest a + // spelling, which can resolve aliases. Doing that in the middle of the + // resolution that failed would make the explanation, and any circularity + // errors it causes, depend on what else happened to be in progress. Defer + // it until no resolution is in progress, so it only observes results. + c.addDeferredDiagnostic(func(c *Checker) { + c.reportFailedToResolveSymbol(errorLocation, name, meaning, nameNotFoundMessage) + }) +} + +func (c *Checker) reportFailedToResolveSymbol(errorLocation *ast.Node, name string, meaning ast.SymbolFlags, nameNotFoundMessage *diagnostics.Message) { // The `const` in a `const` assertion (`x as const`) is a syntactic marker, not a real // type reference, and must never be resolved or reported as an unresolvable name. if isConstTypeReferenceName(errorLocation) { @@ -2236,14 +2451,16 @@ func (c *Checker) getTypeOnlyAliasDeclarationEx(symbol *ast.Symbol, meaning ast. func (c *Checker) getImmediateAliasedSymbol(symbol *ast.Symbol) *ast.Symbol { debug.Assert(symbol.Flags()&ast.SymbolFlagsAlias != 0, "Should only get Alias here.") links := c.aliasSymbolLinks.Get(symbol) - if links.immediateTarget == nil { + if links.immediateTarget.cached(c) == nil { node := c.getDeclarationOfAliasSymbol(symbol) if node == nil { panic("Unexpected nil in getImmediateAliasedSymbol") } - links.immediateTarget = c.getTargetOfAliasDeclaration(node, true /*dontRecursivelyResolve*/) + links.immediateTarget.begin(c) + links.immediateTarget.set(c, c.getTargetOfAliasDeclaration(node, true /*dontRecursivelyResolve*/)) + c.endMemo() } - return links.immediateTarget + return links.immediateTarget.cached(c) } func (c *Checker) addTypeOnlyDeclarationRelatedInfo(diagnostic *ast.Diagnostic, typeOnlyDeclaration *ast.Node, name string) *ast.Diagnostic { @@ -2256,7 +2473,21 @@ func (c *Checker) addTypeOnlyDeclarationRelatedInfo(diagnostic *ast.Diagnostic, func (c *Checker) getSymbol(symbols ast.SymbolTable, name string, meaning ast.SymbolFlags) *ast.Symbol { if meaning&ast.SymbolFlagsAll != 0 { - symbol := c.getMergedSymbol(symbols.Get(name)) + symbol := symbols.Get(name) + if symbol == nil { + return nil + } + // Late binding can only merge member declarations into a symbol, so + // skip it when those could not make the symbol match. Resolving the + // late-bound members here would otherwise be circular when looking up + // a name inside one of their computed property names. + if merged := c.mergedSymbolOf(symbol); merged != nil { + symbol = merged + } + if symbol.Flags()&(meaning|ast.SymbolFlagsAlias) == 0 && meaning&(ast.SymbolFlagsClassMember|ast.SymbolFlagsAssignment) == 0 { + return nil + } + symbol = c.getMergedSymbol(symbol) if symbol != nil { if symbol.Flags()&meaning != 0 { return symbol @@ -2275,6 +2506,10 @@ func (c *Checker) getSymbol(symbols ast.SymbolTable, name string, meaning ast.Sy } func (c *Checker) checkSourceFile(ctx context.Context, sourceFile *ast.SourceFile, checkUnused bool) { + c.withChecking(func() { c.checkSourceFileWorker(ctx, sourceFile, checkUnused) }) +} + +func (c *Checker) checkSourceFileWorker(ctx context.Context, sourceFile *ast.SourceFile, checkUnused bool) { c.ctx = ctx links := c.sourceFileLinks.Get(sourceFile) if !links.typeChecked { @@ -2283,7 +2518,6 @@ func (c *Checker) checkSourceFile(ctx context.Context, sourceFile *ast.SourceFil } // Grammar checking c.checkGrammarSourceFile(sourceFile) - c.renamedBindingElementsInTypes = nil c.checkSourceElements(sourceFile.Statements.Nodes) c.checkDeferredNodes(sourceFile) if ast.IsExternalOrCommonJSModule(sourceFile) { @@ -2291,10 +2525,10 @@ func (c *Checker) checkSourceFile(ctx context.Context, sourceFile *ast.SourceFil c.registerForUnusedIdentifiersCheck(sourceFile.AsNode()) } if !sourceFile.IsDeclarationFile && !c.isCanceled() { - c.checkUnusedRenamedBindingElements() + c.checkUnusedRenamedBindingElements(sourceFile) } + c.checkExternalHelperRequests(sourceFile) c.produceDeferredDiagnostics() - c.reportedUnreachableNodes.Clear() links.typeChecked = true } if checkUnused && !links.unusedChecked { @@ -2321,12 +2555,16 @@ func (c *Checker) checkSourceElements(nodes []*ast.Node) { func (c *Checker) checkSourceElement(node *ast.Node) bool { if node != nil { - saveCurrentNode := c.currentNode + saveCurrentNode, shared := c.enterSharedCurrentNode(node) + if !shared { + saveCurrentNode = c.enterCurrentNode(node) + } saveWithinUnreachableCode := c.withinUnreachableCode - c.currentNode = node c.instantiationCount = 0 c.checkSourceElementWorker(node) - c.currentNode = saveCurrentNode + if !c.exitSharedCurrentNode(saveCurrentNode) { + c.exitCurrentNode(saveCurrentNode) + } c.withinUnreachableCode = saveWithinUnreachableCode } return false @@ -2471,64 +2709,64 @@ func (c *Checker) checkSourceElementWorker(node *ast.Node) { } func (c *Checker) checkSourceElementUnreachable(node *ast.Node) bool { - if !ast.IsPotentiallyExecutableNode(node) { - return false - } - - if c.reportedUnreachableNodes.Has(node) { - return true - } - - if !c.isSourceElementUnreachable(node) { + if !ast.IsPotentiallyExecutableNode(node) || !c.isSourceElementUnreachable(node) { return false } - - c.reportedUnreachableNodes.Add(node) - - sourceFile := ast.GetSourceFileOfNode(node) - + // Report the whole run of unreachable statements containing node once, at + // the same range whichever statement of the run is checked first. startNode := node endNode := node - - parent := node.Parent - if parent.CanHaveStatements() { - statements := parent.Statements() - if offset := slices.Index(statements, node); offset >= 0 { - // Scan backwards to find the first unreachable unreported node; - // this may happen when producing region diagnostics where not all nodes - // will have been visited. - // TODO: enable this code once we support region diagnostics again. - first := offset - // for i := offset - 1; i >= 0; i-- { - // prevNode := statements[i] - // if !ast.IsPotentiallyExecutableNode(prevNode) || c.reportedUnreachableNodes.Has(prevNode) || !c.isSourceElementUnreachable(prevNode) { - // break - // } - // firstUnreachableIndex = i - // c.reportedUnreachableNodes.Add(prevNode) - // } - - last := offset - for i := offset + 1; i < len(statements); i++ { - nextNode := statements[i] - if !ast.IsPotentiallyExecutableNode(nextNode) || !c.isSourceElementUnreachable(nextNode) { - break - } - last = i - c.reportedUnreachableNodes.Add(nextNode) - } - - startNode = statements[first] - endNode = statements[last] + if parent := node.Parent; parent.CanHaveStatements() { + if run, ok := c.getUnreachableRuns(parent)[node]; ok { + startNode = run.start + endNode = run.end } } + c.reportedUnreachableNodes.once(c, startNode, func() { + sourceFile := ast.GetSourceFileOfNode(node) + start := scanner.GetTokenPosOfNode(startNode, sourceFile, false /*includeJSDoc*/) + diagnostic := ast.NewDiagnostic(sourceFile, core.NewTextRange(start, endNode.End()), diagnostics.Unreachable_code_detected) + c.addErrorOrSuggestion(c.compilerOptions.AllowUnreachableCode == core.TSFalse, diagnostic) + }) + return true +} - start := scanner.GetTokenPosOfNode(startNode, sourceFile, false /*includeJSDoc*/) - - diagnostic := ast.NewDiagnostic(sourceFile, core.NewTextRange(start, endNode.End()), diagnostics.Unreachable_code_detected) - c.addErrorOrSuggestion(c.compilerOptions.AllowUnreachableCode == core.TSFalse, diagnostic) +type unreachableRun struct { + start *ast.Node + end *ast.Node +} - return true +// getUnreachableRuns returns the run of unreachable statements containing +// each unreachable statement of container. The runs are found together, so +// checking every statement of a long run does not rescan it each time. +func (c *Checker) getUnreachableRuns(container *ast.Node) map[*ast.Node]unreachableRun { + if runs, ok := c.unreachableRuns.cached(c, container); ok { + return runs + } + return c.unreachableRuns.compute(c, container, func() map[*ast.Node]unreachableRun { + var runs map[*ast.Node]unreachableRun + isUnreachable := func(n *ast.Node) bool { + return ast.IsPotentiallyExecutableNode(n) && c.isSourceElementUnreachable(n) + } + statements := container.Statements() + for i := 0; i < len(statements); i++ { + if !isUnreachable(statements[i]) { + continue + } + first := i + for i+1 < len(statements) && isUnreachable(statements[i+1]) { + i++ + } + run := unreachableRun{statements[first], statements[i]} + if runs == nil { + runs = make(map[*ast.Node]unreachableRun) + } + for _, statement := range statements[first : i+1] { + runs[statement] = run + } + } + return runs + }) } func (c *Checker) isSourceElementUnreachable(node *ast.Node) bool { @@ -2563,6 +2801,10 @@ func (c *Checker) isSourceElementUnreachable(node *ast.Node) bool { // determining the type of foo would cause foo to be given type any because of the recursive reference. // Delaying the type check of the body ensures foo has been assigned a type. func (c *Checker) checkNodeDeferred(node *ast.Node) { + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.checkNodeDeferred(node) }) + return + } enclosingFile := ast.GetSourceFileOfNode(node) links := c.sourceFileLinks.Get(enclosingFile) if !links.typeChecked { @@ -2585,8 +2827,10 @@ func (c *Checker) checkDeferredNode(node *ast.Node) { if tr := c.tracer; tr != nil { defer tr.Push(tracing.PhaseCheck, "checkDeferredNode", map[string]any{"kind": node.Kind, "pos": node.Pos(), "end": node.End(), "path": ast.GetSourceFileOfNode(node).FileName()}, false)() } - saveCurrentNode := c.currentNode - c.currentNode = node + saveCurrentNode, shared := c.enterSharedCurrentNode(node) + if !shared { + saveCurrentNode = c.enterCurrentNode(node) + } c.instantiationCount = 0 switch node.Kind { case ast.KindCallExpression, ast.KindNewExpression, ast.KindTaggedTemplateExpression, ast.KindDecorator, ast.KindJsxOpeningElement: @@ -2616,7 +2860,9 @@ func (c *Checker) checkDeferredNode(node *ast.Node) { case ast.KindObjectLiteralExpression, ast.KindJsxAttributes: c.checkContextualDeprecations(node) } - c.currentNode = saveCurrentNode + if !c.exitSharedCurrentNode(saveCurrentNode) { + c.exitCurrentNode(saveCurrentNode) + } } func (c *Checker) checkJSDocComments(node *ast.Node) { @@ -3045,17 +3291,16 @@ func (c *Checker) checkAccessorDeclaration(node *ast.Node) { symbol := c.getSymbolOfDeclaration(node) getter := ast.GetDeclarationOfKind(symbol, ast.KindGetAccessor) setter := ast.GetDeclarationOfKind(symbol, ast.KindSetAccessor) - if getter != nil && setter != nil && c.nodeLinks.Get(getter).flags&NodeCheckFlagsTypeChecked == 0 { - c.nodeLinks.Get(getter).flags |= NodeCheckFlagsTypeChecked + // Each accessor of the pair reports the errors on its own name, so that + // they do not depend on which of the two is checked first. + if getter != nil && setter != nil && (node == getter || node == setter) { getterFlags := getter.ModifierFlags() setterFlags := setter.ModifierFlags() if (getterFlags & ast.ModifierFlagsAbstract) != (setterFlags & ast.ModifierFlagsAbstract) { - c.error(getter.Name(), diagnostics.Accessors_must_both_be_abstract_or_non_abstract) - c.error(setter.Name(), diagnostics.Accessors_must_both_be_abstract_or_non_abstract) + c.error(node.Name(), diagnostics.Accessors_must_both_be_abstract_or_non_abstract) } if ((getterFlags&ast.ModifierFlagsProtected != 0) && setterFlags&(ast.ModifierFlagsProtected|ast.ModifierFlagsPrivate) == 0) || ((getterFlags&ast.ModifierFlagsPrivate != 0) && setterFlags&ast.ModifierFlagsPrivate == 0) { - c.error(getter.Name(), diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter) - c.error(setter.Name(), diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter) + c.error(node.Name(), diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter) } } } @@ -3094,7 +3339,7 @@ func (c *Checker) checkTypeReferenceOrImport(node *ast.Node) { c.checkTypeArgumentConstraints(node, typeParameters) } } - symbol := c.getResolvedSymbolOrNil(node) + symbol := c.getSymbolOfTypeNode(node) if symbol != nil { if core.Some(symbol.Declarations(), func(d *ast.Node) bool { return ast.IsTypeDeclaration(d) && c.IsDeprecatedDeclaration(d) }) { c.addDeprecatedSuggestion(c.getDeprecatedSuggestionNode(node), symbol.Declarations(), symbol.Name()) @@ -3218,12 +3463,12 @@ func (c *Checker) checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern } func (c *Checker) checkTypeQuery(node *ast.Node) { - c.getTypeFromTypeQueryNode(node) + memoTypeNode(c, node, (*Checker).getTypeFromTypeQueryNode) } func (c *Checker) checkTypeLiteral(node *ast.Node) { c.checkSourceElements(node.Members()) - t := c.getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) + t := memoTypeNode(c, node, (*Checker).getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode) c.checkIndexConstraints(t, t.symbol, false /*isStaticIndex*/) c.checkTypeForDuplicateIndexSignatures(node) c.checkObjectTypeForDuplicateDeclarations(node, false /*checkPrivateNames*/) @@ -3363,7 +3608,7 @@ func (c *Checker) checkUnionOrIntersectionType(node *ast.Node) { } func (c *Checker) checkThisType(node *ast.Node) { - c.getTypeFromThisTypeNode(node) + memoTypeNode(c, node, (*Checker).getTypeFromThisTypeNode) } func (c *Checker) checkTypeOperator(node *ast.Node) { @@ -3385,9 +3630,7 @@ func (c *Checker) checkInferType(node *ast.Node) { c.checkSourceElement(typeParameterDeclarationNode) symbol := c.getSymbolOfDeclaration(typeParameterDeclarationNode) if len(symbol.Declarations()) > 1 { - links := c.declaredTypeLinks.Get(symbol) - if !links.typeParametersChecked { - links.typeParametersChecked = true + c.typeParametersChecked.once(c, symbol, func() { typeParameter := c.getDeclaredTypeOfTypeParameter(symbol) declarations := getDeclarationsOfKind(symbol, ast.KindTypeParameter) if !c.areTypeParametersIdentical(declarations, []*Type{typeParameter}, func(decl *ast.Node) []*ast.Node { return []*ast.Node{decl} }) { @@ -3397,7 +3640,7 @@ func (c *Checker) checkInferType(node *ast.Node) { c.error(declaration.Name(), diagnostics.All_declarations_of_0_must_have_identical_constraints, name) } } - } + }) } c.registerForUnusedIdentifiersCheck(node) } @@ -3448,7 +3691,7 @@ func (c *Checker) checkNamedTupleMember(node *ast.Node) { func (c *Checker) checkIndexedAccessType(node *ast.Node) { node.ForEachChild(c.checkSourceElement) - c.checkIndexedAccessIndexType(c.getTypeFromIndexedAccessTypeNode(node), node) + c.checkIndexedAccessIndexType(memoTypeNode(c, node, (*Checker).getTypeFromIndexedAccessTypeNode), node) } func (c *Checker) checkMappedType(node *ast.Node) { @@ -3460,7 +3703,7 @@ func (c *Checker) checkMappedType(node *ast.Node) { if mappedTypeNode.Type == nil { c.reportImplicitAny(node, c.anyType, WideningKindNormal) } - t := c.getTypeFromMappedTypeNode(node) + t := memoTypeNode(c, node, (*Checker).getTypeFromMappedTypeNode) nameType := c.getNameTypeFromMappedType(t) if nameType != nil { c.checkTypeAssignableTo(nameType, c.stringNumberSymbolType, mappedTypeNode.NameType, nil) @@ -3529,10 +3772,7 @@ func (c *Checker) checkFunctionOrMethodDeclaration(node *ast.Node) { } func (c *Checker) checkFunctionOrConstructorSymbol(symbol *ast.Symbol) { - // Only check the symbol once - if c.constructorOrFunctionChecked.AddIfAbsent(symbol) { - c.checkFunctionOrConstructorSymbolWorker(symbol) - } + c.constructorOrFunctionChecked.once(c, symbol, func() { c.checkFunctionOrConstructorSymbolWorker(symbol) }) } func (c *Checker) checkFunctionOrConstructorSymbolWorker(symbol *ast.Symbol) { @@ -3857,13 +4097,7 @@ func (c *Checker) checkBlock(node *ast.Node) { if node.Kind == ast.KindBlock { c.checkGrammarStatementInAmbientContext(node) } - if ast.IsFunctionOrModuleBlock(node) { - saveFlowAnalysisDisabled := c.flowAnalysisDisabled - c.checkSourceElements(node.Statements()) - c.flowAnalysisDisabled = saveFlowAnalysisDisabled - } else { - c.checkSourceElements(node.Statements()) - } + c.checkSourceElements(node.Statements()) if node.Locals().Len() != 0 { c.registerForUnusedIdentifiersCheck(node) } @@ -3913,7 +4147,7 @@ func (c *Checker) checkTestingKnownTruthyType(condExpr *ast.Node, condType *Type if location != condExpr { t = c.checkExpression(location) } - if t.flags&TypeFlagsEnumLiteral != 0 && ast.IsPropertyAccessExpression(location) && core.OrElse(c.getResolvedSymbolOrNil(location.Expression()), c.unknownSymbol).Flags()&ast.SymbolFlagsEnum != 0 { + if t.flags&TypeFlagsEnumLiteral != 0 && ast.IsPropertyAccessExpression(location) && core.OrElse(c.symbolOfCheckedExpression(location.Expression()), c.unknownSymbol).Flags()&ast.SymbolFlagsEnum != 0 { // EnumLiteral type at condition with known value is always truthy or always falsy, likely an error c.error(location, diagnostics.This_condition_will_always_return_0, core.IfElse(evaluator.IsTruthy(t.AsLiteralType().value), "true", "false")) return @@ -4506,9 +4740,7 @@ func (c *Checker) checkTypeParameterListsIdentical(symbol *ast.Symbol) { if len(symbol.Declarations()) == 1 { return } - links := c.declaredTypeLinks.Get(symbol) - if !links.typeParametersChecked { - links.typeParametersChecked = true + c.typeParametersChecked.once(c, symbol, func() { declarations := c.getClassOrInterfaceDeclarationsOfSymbol(symbol) if len(declarations) <= 1 { return @@ -4521,7 +4753,7 @@ func (c *Checker) checkTypeParameterListsIdentical(symbol *ast.Symbol) { c.error(declaration.Name(), diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name) } } - } + }) } func (c *Checker) getClassOrInterfaceDeclarationsOfSymbol(symbol *ast.Symbol) []*ast.Node { @@ -4607,8 +4839,8 @@ func (c *Checker) getTypeWithoutSignatures(t *Type) *Type { if len(resolved.getSignatures()) != 0 { result := c.newObjectType(ObjectFlagsAnonymous, t.symbol) result.objectFlags |= ObjectFlagsMembersResolved - result.AsObjectType().members = resolved.getMembers() - result.AsObjectType().properties = resolved.getProperties() + result.AsObjectType().members = resolved.getMembers(c) + result.AsObjectType().properties = resolved.getProperties(c) return result } case t.flags&TypeFlagsIntersection != 0: @@ -5018,10 +5250,9 @@ func (c *Checker) checkIndexConstraintForIndexSignature(t *Type, checkInfo *Inde func (c *Checker) checkClassOrInterfaceForDuplicateIndexSignatures(node *ast.Node) { // Only check the type once - if links := c.declaredTypeLinks.Get(c.getSymbolOfDeclaration(node)); !links.indexSignaturesChecked { - links.indexSignaturesChecked = true + c.indexSignaturesChecked.once(c, c.getSymbolOfDeclaration(node), func() { c.checkTypeForDuplicateIndexSignatures(node) - } + }) } func (c *Checker) checkTypeForDuplicateIndexSignatures(node *ast.Node) { @@ -5125,8 +5356,7 @@ func (c *Checker) checkInterfaceDeclaration(node *ast.Node) { c.checkTypeParameterListsIdentical(symbol) // Check once per checker, but report on the first interface declaration, // independently of which declaration is checked first. - if links := c.declaredTypeLinks.Get(symbol); !links.interfaceChecked { - links.interfaceChecked = true + c.interfaceChecked.once(c, symbol, func() { firstInterfaceDeclaration := ast.GetDeclarationOfKind(symbol, ast.KindInterfaceDeclaration) t := c.getDeclaredTypeOfSymbol(symbol) typeWithThis := c.getTypeWithThisArgument(t, nil, false) @@ -5137,7 +5367,8 @@ func (c *Checker) checkInterfaceDeclaration(node *ast.Node) { } c.checkIndexConstraints(t, symbol /*isStaticIndex*/, false) } - } + }) + c.checkObjectTypeForDuplicateDeclarations(node, false /*checkPrivateNames*/) for _, heritageElement := range ast.GetExtendsHeritageClauseElements(node) { if ast.IsExpressionWithTypeArguments(heritageElement) { @@ -5212,8 +5443,7 @@ func (c *Checker) checkEnumDeclaration(node *ast.Node) { // // Only perform this check once per symbol enumSymbol := c.getSymbolOfDeclaration(node) - if links := c.declaredTypeLinks.Get(enumSymbol); !links.enumChecked { - links.enumChecked = true + c.enumChecked.once(c, enumSymbol, func() { if len(enumSymbol.Declarations()) > 1 { firstEnumDeclaration := ast.GetDeclarationOfKind(enumSymbol, ast.KindEnumDeclaration) enumIsConst := ast.IsEnumConst(firstEnumDeclaration) @@ -5243,7 +5473,7 @@ func (c *Checker) checkEnumDeclaration(node *ast.Node) { } } } - } + }) } func (c *Checker) checkEnumMember(node *ast.Node) { @@ -5253,8 +5483,11 @@ func (c *Checker) checkEnumMember(node *ast.Node) { if ast.IsComputedPropertyName(node.Name()) { c.checkExpression(node.Name().Expression()) } - if node.Initializer() != nil { - c.checkExpression(node.Initializer()) + if initializer := node.Initializer(); initializer != nil { + initializerType := c.checkExpression(initializer) + if c.getEnumMemberValue(node).Value == nil && !ast.IsEnumConst(node.Parent) && node.Parent.Flags&ast.NodeFlagsAmbient == 0 { + c.checkTypeAssignableTo(initializerType, c.numberType, initializer, diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values) + } } } @@ -5373,9 +5606,10 @@ func (c *Checker) getTypeOfModuleDeclarationImportAttributes(attributes *ast.Typ } func (c *Checker) getTypeOfModuleImportAttributes(symbol *ast.Symbol) *Type { - if t, ok := c.moduleImportAttributesTypes[symbol]; ok { + if t, ok := c.moduleImportAttributesTypes.cached(c, symbol); ok { return t } + c.moduleImportAttributesTypes.begin(c, symbol) var result *Type moduleDecl := core.Find(symbol.Declarations(), ast.IsModuleWithStringLiteralName) if moduleDecl == nil { @@ -5383,7 +5617,8 @@ func (c *Checker) getTypeOfModuleImportAttributes(symbol *ast.Symbol) *Type { } else { result = c.getTypeOfModuleDeclarationImportAttributes(moduleDecl.AsModuleDeclaration().Attributes) } - c.moduleImportAttributesTypes[symbol] = result + c.moduleImportAttributesTypes.set(c, symbol, result) + c.endMemo() return result } @@ -5532,9 +5767,10 @@ func (c *Checker) checkExternalImportOrExportDeclaration(node *ast.Node) bool { if !ast.IsImportEqualsDeclaration(node) { attributes := ast.GetImportAttributes(node) if attributes != nil { - if c.checkGrammarImportAttributeValues(attributes.AsImportAttributes()) { - return false - } + // As for an import type, invalid attribute values leave the + // imported names to be checked, as resolving them for any query + // would check them. + c.checkGrammarImportAttributeValues(attributes.AsImportAttributes()) } } return true @@ -5616,19 +5852,19 @@ func (c *Checker) getTypeFromImportAttributes(node *ast.Node) *Type { func (c *Checker) checkImportAttributesExpression(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { symbol := c.newSymbol(ast.SymbolFlagsObjectLiteral, ast.InternalSymbolNameImportAttributes) members := ast.NewSymbolTable() for _, attribute := range node.AsImportAttributes().Attributes.Nodes { member := c.newSymbol(ast.SymbolFlagsProperty, attribute.Name().Text()) - c.valueSymbolLinks.Get(member).resolvedType = c.getRegularTypeOfLiteralType(c.checkExpressionCached(attribute.AsImportAttribute().Value)) + c.valueSymbolLinks.Get(member).resolvedType.setIdentity(c, c.getRegularTypeOfLiteralType(c.checkExpressionCached(attribute.AsImportAttribute().Value))) members.Set(member.Name(), member) } t := c.newAnonymousType(symbol, members, nil, nil, nil) t.objectFlags |= ObjectFlagsObjectLiteral | ObjectFlagsNonInferrableType - links.resolvedType = t + links.resolvedType.set(c, t) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getImportAttributesTypeForModuleSpecifier(moduleSpecifier *ast.Node) *Type { @@ -5895,8 +6131,7 @@ func getVerbatimModuleSyntaxErrorMessage(node *ast.Node) *diagnostics.Message { func (c *Checker) checkExternalModuleExports(node *ast.Node) { moduleSymbol := c.getSymbolOfDeclaration(node) - links := c.moduleSymbolLinks.Get(moduleSymbol) - if !links.exportsChecked { + c.moduleExportsChecked.once(c, moduleSymbol, func() { exportEqualsSymbol := moduleSymbol.Exports().Get(ast.InternalSymbolNameExportEquals) // An export assignment is in error if (a) the module exports value members or (b) if the module exports type or // namespace members and the exported entity also exports type or namespace members. @@ -5934,8 +6169,7 @@ func (c *Checker) checkExternalModuleExports(node *ast.Node) { } } } - links.exportsChecked = true - } + }) } func (c *Checker) hasExportedMembersOfKind(moduleSymbol *ast.Symbol, kind ast.SymbolFlags) bool { @@ -6023,7 +6257,10 @@ func (c *Checker) checkVariableLikeDeclaration(node *ast.Node) { // ^^^^^^ // variable renaming in function type notation is confusing, // so we forbid it even if noUnusedLocals is not enabled - c.renamedBindingElementsInTypes = append(c.renamedBindingElementsInTypes, node) + c.sourceFileLinks.Get(ast.GetSourceFileOfNode(node)).renamedBindingElements.Add(node) + if !c.checking { + return + } // Still resolve the type like the end of this function does for every other declaration, // so implicit any errors are reported by checking instead of by whatever asks for the type later c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)) @@ -6243,6 +6480,13 @@ func (c *Checker) checkDecorators(node *ast.Node) { // skip this check for nodes that cannot have decorators. These should have already had an error reported by // checkGrammarModifiers. if !ast.CanHaveDecorators(node) || !ast.HasDecorators(node) || !ast.NodeCanBeDecorated(c.legacyDecorators, node, node.Parent, node.Parent.Parent) { + // The expressions of decorators that are not valid here are still + // checked, as they are when anything computes their types. + for _, modifier := range node.ModifierNodes() { + if ast.IsDecorator(modifier) { + c.checkExpression(modifier.Expression()) + } + } return } firstDecorator := core.Find(node.ModifierNodes(), ast.IsDecorator) @@ -6288,11 +6532,11 @@ func (c *Checker) checkDecorator(node *ast.Node) { } // if we fail to get a signature and return type here, we will have already reported a grammar error in `checkDecorators`. decoratorSignature := c.getDecoratorCallSignature(node) - if decoratorSignature == nil || decoratorSignature.resolvedReturnType == nil { + if decoratorSignature == nil { return } var headMessage *diagnostics.Message - expectedReturnType := decoratorSignature.resolvedReturnType + expectedReturnType := c.getReturnTypeOfSignature(decoratorSignature) switch node.Parent.Kind { case ast.KindClassDeclaration, ast.KindClassExpression: headMessage = diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1 @@ -6487,20 +6731,24 @@ func (c *Checker) getIterationTypesOfIterable(t *Type, use IterationUse, errorNo if IsTypeAny(t) { return IterationTypes{c.anyType, c.anyType, c.anyType} } - key := IterationTypesKey{typeId: t.id, use: use & IterationUseCacheFlags} - // If we are reporting errors and encounter a cached `noIterationTypes`, we should ignore the cached value and continue as if nothing was cached. - // In addition, we should not cache any new results for this call. - noCache := false - if cached, ok := c.iterationTypesCache[key]; ok { - if errorNode == nil || cached.hasTypes() { - return cached - } - noCache = true + if errorNode != nil { + // Errors belong to errorNode, so compute them here rather than + // cache them with the types every other use of t shares. + return c.getIterationTypesOfIterableWorker(t, use, errorNode) } - result := c.getIterationTypesOfIterableWorker(t, use, errorNode) - if !noCache { - c.iterationTypesCache[key] = result + key := IterationTypesKey{typeId: t.id, use: use & IterationUseCacheFlags} + c.iterationTypesCache.begin(c, key) + result := c.getIterationTypesOfIterableCached(t, use, key) + c.endMemo() + return result +} + +func (c *Checker) getIterationTypesOfIterableCached(t *Type, use IterationUse, key IterationTypesKey) IterationTypes { + if cached, ok := c.iterationTypesCache.cached(c, key); ok { + return cached } + result := c.getIterationTypesOfIterableWorker(t, use, nil /*errorNode*/) + c.iterationTypesCache.set(c, key, result) return result } @@ -6511,7 +6759,7 @@ func (c *Checker) getIterationTypesOfIterableWorker(t *Type, use IterationUse, e iterationTypes := c.getIterationTypesOfIterableWorker(constituent, use, nil) if !iterationTypes.hasTypes() { if errorNode != nil { - c.addDeferredDiagnostic(func() { + c.addDeferredDiagnostic(func(c *Checker) { c.reportTypeNotIterableError(errorNode, t, use&IterationUseAllowsAsyncIterablesFlag != 0) }) } @@ -6564,7 +6812,7 @@ func (c *Checker) getIterationTypesOfIterableWorker(t *Type, use IterationUse, e if errorNode != nil { // We defer the diagnostic because TypeToString may attempt to resolve symbols that are already being // resolved, possibly causing circularities. - c.addDeferredDiagnostic(func() { + c.addDeferredDiagnostic(func(c *Checker) { diagnostic := c.reportTypeNotIterableError(errorNode, t, use&IterationUseAllowsAsyncIterablesFlag != 0) for _, d := range diags { diagnostic.AddRelatedInfo(d) @@ -7141,9 +7389,13 @@ func (c *Checker) checkExportsOnMergedDeclarations(node *ast.Node) { return } } - if len(symbol.Declarations()) < 2 || !c.mergedExportsChecked.AddIfAbsent(symbol) { + if len(symbol.Declarations()) < 2 { return } + c.mergedExportsChecked.once(c, symbol, func() { c.checkExportsOnMergedDeclarationsWorker(symbol) }) +} + +func (c *Checker) checkExportsOnMergedDeclarationsWorker(symbol *ast.Symbol) { exportedDeclarationSpaces := DeclarationSpacesNone nonExportedDeclarationSpaces := DeclarationSpacesNone defaultExportedDeclarationSpaces := DeclarationSpacesNone @@ -7259,6 +7511,10 @@ func (c *Checker) checkTypeParametersNotReferenced(root *ast.Node, typeParameter } func (c *Checker) registerForUnusedIdentifiersCheck(node *ast.Node) { + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.registerForUnusedIdentifiersCheck(node) }) + return + } sourceFile := ast.GetSourceFileOfNode(node) links := c.sourceFileLinks.Get(sourceFile) links.identifierCheckNodes = append(links.identifierCheckNodes, node) @@ -7532,8 +7788,8 @@ func (c *Checker) isUnreferencedTypeParameter(typeParameter *ast.Node) bool { return c.symbolReferenceLinks.Get(c.getMergedSymbol(typeParameter.Symbol())).referenceKinds&ast.SymbolFlagsTypeParameter == 0 && !isIdentifierThatStartsWithUnderscore(typeParameter.Name()) } -func (c *Checker) checkUnusedRenamedBindingElements() { - for _, node := range c.renamedBindingElementsInTypes { +func (c *Checker) checkUnusedRenamedBindingElements(sourceFile *ast.SourceFile) { + for node := range c.sourceFileLinks.Get(sourceFile).renamedBindingElements.Values() { if c.symbolReferenceLinks.Get(c.getSymbolOfDeclaration(node)).referenceKinds == 0 { wrappingDeclaration := ast.WalkUpBindingElementsAndPatterns(node) debug.Assert(ast.IsPartOfParameterDeclaration(wrappingDeclaration), "Only parameter declaration should be checked here") @@ -7561,18 +7817,44 @@ func (c *Checker) getTypeOfExpression(node *ast.Node) *Type { if quickType != nil { return quickType } - // If a type has been cached for the node, return it. + if len(c.flowLoopStack) == 0 { + // Outside loop analysis, the type is independent of the flow state in + // progress, so it is cached in the store. + if t, ok := c.flowExpressionTypes.cached(c, node); ok { + return t + } + c.flowExpressionTypes.begin(c, node) + startInvocationCount := c.flowInvocationCount + t := c.checkExpressionEx(node, CheckModeTypeOnly) + // If control flow analysis was required to determine the type, it is worth caching. + if c.flowInvocationCount != startInvocationCount { + c.flowExpressionTypes.set(c, node, t) + c.endMemo() + } else { + c.endMemoUncached() + } + return t + } + // Within loop analysis, the type may depend on the transient types of the + // loop, so it is only cached until the analysis of the loop is restarted. + key := memoKeyOf(node, memoFlowExpressionType) if cachedType := c.flowTypeCache[node]; cachedType != nil { + if c.memoActive() { + c.observeMemo(key) + } return cachedType } + c.beginMemo(key) startInvocationCount := c.flowInvocationCount t := c.checkExpressionEx(node, CheckModeTypeOnly) - // If control flow analysis was required to determine the type, it is worth caching. if c.flowInvocationCount != startInvocationCount { if c.flowTypeCache == nil { c.flowTypeCache = make(map[*ast.Node]*Type) } c.flowTypeCache[node] = t + c.endMemo() + } else { + c.endMemoUncached() } return t } @@ -7740,7 +8022,21 @@ func (c *Checker) checkExpressionCachedEx(node *ast.Node, checkMode CheckMode) * return c.checkExpressionEx(node, checkMode) } links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if t := links.resolvedType.cached(c); t != nil { + return t + } + links.resolvedType.begin(c) + result := c.checkExpressionCachedExUncached(node, checkMode) + c.endMemo() + return result +} + +func (c *Checker) checkExpressionCachedExUncached(node *ast.Node, checkMode CheckMode) *Type { + if checkMode != CheckModeNormal { + return c.checkExpressionEx(node, checkMode) + } + links := c.typeNodeLinks.Get(node) + if links.resolvedType.cached(c) == nil { // When computing a type that we're going to cache, we need to ignore any ongoing control flow // analysis because variables may have transient types in indeterminable states. Moving flowLoopStart // to the top of the stack ensures all transient types are computed from a known point. @@ -7748,11 +8044,11 @@ func (c *Checker) checkExpressionCachedEx(node *ast.Node, checkMode CheckMode) * saveFlowTypeCache := c.flowTypeCache c.flowLoopStack = nil c.flowTypeCache = nil - links.resolvedType = c.checkExpressionEx(node, checkMode) + links.resolvedType.set(c, c.checkExpressionEx(node, checkMode)) c.flowTypeCache = saveFlowTypeCache c.flowLoopStack = saveFlowLoopStack } - return links.resolvedType + return links.resolvedType.cached(c) } // Returns the type of an expression. Unlike checkExpression, this function is simply concerned @@ -7761,12 +8057,14 @@ func (c *Checker) checkExpressionCachedEx(node *ast.Node, checkMode CheckMode) * // and requesting the contextual type might cause a circularity or other bad behaviour. // It sets the contextual type of the node to any before calling getTypeOfExpression. func (c *Checker) getContextFreeTypeOfExpression(node *ast.Node) *Type { - if cached := c.contextFreeTypes[node]; cached != nil { + if cached, _ := c.contextFreeTypes.cached(c, node); cached != nil { return cached } + c.contextFreeTypes.begin(c, node) c.pushContextualType(node, c.anyType, false /*isCache*/) t := c.checkExpressionEx(node, CheckModeSkipContextSensitive) - c.contextFreeTypes[node] = t + c.contextFreeTypes.set(c, node, t) + c.endMemo() c.popContextualType() return t } @@ -7779,15 +8077,19 @@ func (c *Checker) checkExpressionEx(node *ast.Node, checkMode CheckMode) *Type { if tr := c.tracer; tr != nil { defer tr.Push(tracing.PhaseCheck, "checkExpression", map[string]any{"kind": node.Kind, "pos": node.Pos(), "end": node.End(), "path": ast.GetSourceFileOfNode(node).FileName()}, false)() } - saveCurrentNode := c.currentNode - c.currentNode = node + saveCurrentNode, shared := c.enterSharedCurrentNode(node) + if !shared { + saveCurrentNode = c.enterCurrentNode(node) + } c.instantiationCount = 0 uninstantiatedType := c.checkExpressionWorker(node, checkMode) t := c.instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode) if isConstEnumObjectType(t) { c.checkConstEnumAccess(node, t) } - c.currentNode = saveCurrentNode + if !c.exitSharedCurrentNode(saveCurrentNode) { + c.exitCurrentNode(saveCurrentNode) + } return t } @@ -8066,10 +8368,10 @@ func (c *Checker) checkPrivateIdentifierExpression(node *ast.Node) *Type { func (c *Checker) getSymbolForPrivateIdentifierExpression(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol == nil { - links.resolvedSymbol = c.lookupSymbolForPrivateIdentifierDeclaration(node.Text(), node) + if links.resolvedSymbol.cached(c) == nil { + links.resolvedSymbol.set(c, c.lookupSymbolForPrivateIdentifierDeclaration(node.Text(), node)) } - return links.resolvedSymbol + return links.resolvedSymbol.cached(c) } func (c *Checker) checkSuperExpression(node *ast.Node) *Type { @@ -8231,11 +8533,9 @@ func (c *Checker) isTemplateLiteralContextualType(t *Type) bool { } func (c *Checker) checkRegularExpressionLiteral(node *ast.Node) *Type { - nodeLinks := c.nodeLinks.Get(node) - if nodeLinks.flags&NodeCheckFlagsTypeChecked == 0 { - nodeLinks.flags |= NodeCheckFlagsTypeChecked + c.checkedRegularExpressions.once(c, node, func() { c.checkGrammarRegularExpressionLiteral(node.AsRegularExpressionLiteral()) - } + }) return c.globalRegExpType } @@ -8248,7 +8548,7 @@ func (c *Checker) checkArrayLiteral(node *ast.Node, checkMode CheckMode) *Type { inConstContext := c.isConstContext(node) contextualType := c.getApparentTypeOfContextualType(node, ContextFlagsNone) inTupleContext := isSpreadIntoCallOrNew(node) || contextualType != nil && someType(contextualType, func(t *Type) bool { - return c.isTupleLikeType(t) || c.isGenericMappedType(t) && t.AsMappedType().nameType == nil && c.getHomomorphicTypeVariable(core.OrElse(t.AsMappedType().target, t)) != nil + return c.isTupleLikeType(t) || c.isGenericMappedType(t) && c.getNameTypeFromMappedType(t) == nil && c.getHomomorphicTypeVariable(core.OrElse(t.AsMappedType().target, t)) != nil }) hasOmittedExpression := false for i, e := range elements { @@ -8326,12 +8626,12 @@ func (c *Checker) createArrayLiteralType(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindArrayLiteralType, typeId: t.id} - if cached, ok := c.cachedTypes[key]; ok { + if cached, ok := c.cachedTypes.cached(c, key); ok { return cached } literalType := c.cloneTypeReference(t) literalType.objectFlags |= ObjectFlagsArrayLiteral | ObjectFlagsContainsObjectOrArrayLiteral - c.cachedTypes[key] = literalType + c.cachedTypes.intern(key, literalType) return literalType } @@ -8392,7 +8692,7 @@ func (c *Checker) checkElementAccessExpression(node *ast.Node, exprType *Type, c core.IfElse(c.isGenericObjectType(objectType) && !isThisTypeParameter(objectType), AccessFlagsNoIndexSignatures, 0) } indexedAccessType := core.OrElse(c.getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node, nil), c.errorType) - return c.checkIndexedAccessIndexType(c.getFlowTypeOfAccessExpression(node, c.getResolvedSymbolOrNil(node), indexedAccessType, indexExpression, checkMode), node) + return c.checkIndexedAccessIndexType(c.getFlowTypeOfAccessExpression(node, c.symbolOfCheckedExpression(node), indexedAccessType, indexExpression, checkMode), node) } // Return true if given node is an expression consisting of an identifier (possibly parenthesized) @@ -8637,6 +8937,68 @@ func (c *Checker) isSymbolOrSymbolForCall(node *ast.Node) bool { return globalESSymbol == c.resolveName(left, "Symbol", ast.SymbolFlagsValue, nil /*nameNotFoundMessage*/, false /*isUse*/, false) } +// isContextuallyTypedByEnclosingCall reports whether the contextual type of +// an expression may come from an argument of an enclosing call. Other +// contexts are not resolved ahead of the expression, since computing them +// may evaluate expressions that checking only evaluates otherwise, such as +// the target of a destructuring assignment. +func isContextuallyTypedByEnclosingCall(node *ast.Node) bool { + for { + parent := node.Parent + switch parent.Kind { + case ast.KindCallExpression, ast.KindNewExpression: + return node != parent.Expression() + case ast.KindTemplateSpan: + // A substitution of a tagged template is an argument of its tag. + return ast.IsTaggedTemplateExpression(parent.Parent.Parent) + case ast.KindJsxOpeningElement, ast.KindJsxSelfClosingElement: + // The attributes are the argument of the element. + return true + case ast.KindJsxElement: + if node == parent.AsJsxElement().OpeningElement { + node = parent + continue + } + // A child is part of the attributes of the element. + return true + case ast.KindParenthesizedExpression, ast.KindNonNullExpression, ast.KindSpreadElement, ast.KindArrayLiteralExpression, + ast.KindObjectLiteralExpression, ast.KindPropertyAssignment, ast.KindSpreadAssignment, ast.KindAwaitExpression, + ast.KindJsxExpression, ast.KindJsxAttribute, ast.KindJsxSpreadAttribute, ast.KindJsxAttributes: + node = parent + continue + case ast.KindAsExpression, ast.KindTypeAssertionExpression: + if !ast.IsConstAssertion(parent) { + return false + } + case ast.KindConditionalExpression: + if node == parent.AsConditionalExpression().Condition { + return false + } + case ast.KindBinaryExpression: + switch parent.AsBinaryExpression().OperatorToken.Kind { + case ast.KindBarBarToken, ast.KindAmpersandAmpersandToken, ast.KindQuestionQuestionToken, ast.KindCommaToken: + if node != parent.AsBinaryExpression().Right { + return false + } + default: + return false + } + case ast.KindArrowFunction: + if node != parent.Body() { + return false + } + case ast.KindReturnStatement, ast.KindYieldExpression: + parent = ast.GetContainingFunction(parent) + if parent == nil || !ast.IsFunctionExpressionOrArrowFunction(parent) { + return false + } + default: + return false + } + node = parent + } +} + /** * Resolve a signature of a given call-like expression. * @param node a call-like expression to try resolve a signature for @@ -8645,15 +9007,52 @@ func (c *Checker) isSymbolOrSymbolForCall(node *ast.Node) bool { * @return a signature of the call-like expression or undefined if one can't be found */ func (c *Checker) getResolvedSignature(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { + // Resolution is located at the call however it was requested, such as + // from contextually typing an argument, so that errors it reports at the + // current node do not depend on which was checked first. + saveCurrentNode, shared := c.enterSharedCurrentNode(node) + if !shared { + saveCurrentNode = c.enterCurrentNode(node) + } + c.signatureLinks.Get(node).resolvedSignature.begin(c) + result := c.getResolvedSignatureUncached(node, candidatesOutArray, checkMode) + c.endMemo() + if !c.exitSharedCurrentNode(saveCurrentNode) { + c.exitCurrentNode(saveCurrentNode) + } + return result +} + +func (c *Checker) getResolvedSignatureUncached(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { links := c.signatureLinks.Get(node) // If getResolvedSignature has already been called, we will have cached the resolvedSignature. // However, it is possible that either candidatesOutArray was not passed in the first time, // or that a different candidatesOutArray was passed in. Therefore, we need to redo the work // to correctly fill the candidatesOutArray. - cached := links.resolvedSignature + cached := links.resolvedSignature.cached(c) + if cached == c.resolvingSignature && c.isSignatureResolutionHidden(links) { + cached = nil + } if cached != nil && cached != c.resolvingSignature && candidatesOutArray == nil { return cached } + if cached == nil { + // Resolve an enclosing call providing the contextual type of this one + // first, as checking in source order would. The enclosing call may also + // type parameters this call references. Resolved from within this call + // instead, the enclosing call sees this one marked as resolving, and + // the result depends on which call was queried first. + if (ast.IsCallExpression(node) || ast.IsNewExpression(node) || ast.IsTaggedTemplateExpression(node) || ast.IsJsxOpeningLikeElement(node)) && isContextuallyTypedByEnclosingCall(node) { + c.getContextualType(node, ContextFlagsNone) + } + cached = links.resolvedSignature.cached(c) + if cached == c.resolvingSignature && c.isSignatureResolutionHidden(links) { + cached = nil + } + if cached != nil && cached != c.resolvingSignature && candidatesOutArray == nil { + return cached + } + } saveResolutionStart := c.resolutionStart if cached == nil { // If we haven't already done so, temporarily reset the resolution stack. This allows us to @@ -8662,34 +9061,65 @@ func (c *Checker) getResolvedSignature(node *ast.Node, candidatesOutArray *[]*Si // through resolution of the containing function call. By resetting the resolution stack we'll // retry the symbol type resolution with the resolvingSignature marker in place to suppress // the contextual type circularity. - c.resolutionStart = len(c.typeResolutions) + c.resolutionStart = len(c.resolutions) } - links.resolvedSignature = c.resolvingSignature + links.resolvedSignature.swap(c.resolvingSignature) + c.signaturesResolving = append(c.signaturesResolving, links) result := c.resolveSignature(node, candidatesOutArray, checkMode) + c.signaturesResolving = c.signaturesResolving[:len(c.signaturesResolving)-1] c.resolutionStart = saveResolutionStart // When CheckMode.SkipGenericFunctions is set we use resolvingSignature to indicate that call - // resolution should be deferred. - if result != c.resolvingSignature { + // resolution should be deferred. The call is then left as it was, unless a resolution of it + // re-entering this one resolved it. + if result == c.resolvingSignature { + if links.resolvedSignature.cached(c) == c.resolvingSignature { + links.resolvedSignature.swap(cached) + } + } else { // if the signature resolution originated on a node that itself depends on the contextual type // then it's possible that the resolved signature might not be the same as the one that would be computed in source order // since resolving such signature leads to resolving the potential outer signature, its arguments and thus the very same signature // it's possible that this inner resolution sets the resolvedSignature first. // In such a case we ignore the local result and reuse the correct one that was cached. - if links.resolvedSignature != c.resolvingSignature { - result = links.resolvedSignature + if links.resolvedSignature.cached(c) != c.resolvingSignature { + result = links.resolvedSignature.cached(c) } // If signature resolution originated in control flow type analysis (for example to compute the // assigned type in a flow assignment) we don't cache the result as it may be based on temporary // types from the control flow analysis. if len(c.flowLoopStack) == 0 { - links.resolvedSignature = result + c.setResolvedSignature(links, result) } else { - links.resolvedSignature = cached + links.resolvedSignature.swap(cached) } } return result } +// setResolvedSignature caches the signature a call resolves to, in place of +// the marker of its resolution, which is only restored while the resolution +// is still in progress. +func (c *Checker) setResolvedSignature(links *SignatureLinks, signature *Signature) { + setAfterMarker(c, &links.resolvedSignature, signature, links, isStaleSignatureMarker) +} + +func isStaleSignatureMarker(c *Checker, links *SignatureLinks, s *Signature) bool { + return s == c.resolvingSignature && !slices.Contains(c.signaturesResolving, links) +} + +// isSignatureResolutionVisible reports whether the resolution of the call with +// the given links is in progress, other than hidden by a cycle yield. +func (c *Checker) isSignatureResolutionVisible(links *SignatureLinks) bool { + return slices.Contains(c.signaturesResolving[c.visibleSignatures:], links) +} + +// isSignatureResolutionHidden reports whether the resolution of the call +// with the given links is in progress below what is visible; see yieldCycle. +func (c *Checker) isSignatureResolutionHidden(links *SignatureLinks) bool { + i := slices.Index(c.signaturesResolving[c.visibleSignatures:], links) + return i < 0 && c.visibleSignatures > 0 && slices.Contains(c.signaturesResolving[:c.visibleSignatures], links) +} + func (c *Checker) resolveSignature(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { switch node.Kind { case ast.KindCallExpression: @@ -9096,7 +9526,7 @@ func (c *Checker) resolveCall(node *ast.Node, signatures []*Signature, candidate isDecorator := node.Kind == ast.KindDecorator isJsxOpeningOrSelfClosingElement := ast.IsJsxOpeningLikeElement(node) isInstanceof := node.Kind == ast.KindBinaryExpression - reportErrors := !c.isInferencePartiallyBlocked && candidatesOutArray == nil + reportErrors := (c.request == nil || !c.request.inferencePartiallyBlocked) && candidatesOutArray == nil var s CallState s.node = node if !isDecorator && !isInstanceof && !isSuperCall(node) && !ast.IsJsxOpeningFragment(node) { @@ -9171,15 +9601,18 @@ func (c *Checker) resolveCall(node *ast.Node, signatures []*Signature, candidate // is just important for choosing the best signature. So in the case where there is only one // signature, the subtype pass is useless. So skipping it is an optimization. var result *Signature - s.recursiveResolution = slices.Contains(c.callResolutionStack, s.node) - c.callResolutionStack = append(c.callResolutionStack, s.node) + if i := c.resolvingAnywhereIndex(s.node, TypeSystemPropertyNameCallResolution); i >= 0 && !c.yieldCycle(i) { + c.markTypeResolutionCircular(i) + s.recursiveResolution = true + } + c.beginTypeResolution(s.node, TypeSystemPropertyNameCallResolution, nil) if len(s.candidates) > 1 { result = c.chooseOverload(&s, c.subtypeRelation) } if result == nil { result = c.chooseOverload(&s, c.assignableRelation) } - c.callResolutionStack = c.callResolutionStack[:len(c.callResolutionStack)-1] + c.popTypeResolution() if result != nil { return result } @@ -9191,7 +9624,7 @@ func (c *Checker) resolveCall(node *ast.Node, signatures []*Signature, candidate // don't hit this issue because they only observe this result after it's had a chance to // be cached, but the error reporting code below executes before getResolvedSignature sets // resolvedSignature. - c.signatureLinks.Get(node).resolvedSignature = result + c.setResolvedSignature(c.signatureLinks.Get(node), result) // No signatures were applicable. Now report errors based on the last applicable signature with // no arguments excluded from assignability checks. // If candidate is undefined, it means that no candidates had a suitable arity. In that case, @@ -9267,12 +9700,14 @@ func (c *Checker) getOptionalCallSignature(signature *Signature, callChainFlags return signature } key := CachedSignatureKey{sig: signature, key: core.IfElse(callChainFlags == SignatureFlagsIsInnerCallChain, SignatureKeyInner, SignatureKeyOuter)} - if cached := c.cachedSignatures[key]; cached != nil { + if cached, _ := c.cachedSignatures.cached(c, key); cached != nil { return cached } + c.cachedSignatures.begin(c, key) result := c.cloneSignature(signature) result.flags |= callChainFlags - c.cachedSignatures[key] = result + c.cachedSignatures.set(c, key, result) + c.endMemo() return result } @@ -9774,8 +10209,8 @@ func (c *Checker) pickLongestCandidateSignature(node *ast.Node, candidates []*Si // declare function f(k: keyof T); // f(" argCount := len(args) - if c.apparentArgumentCount != nil { - argCount = *c.apparentArgumentCount + if c.request != nil && c.request.argumentCount != nil { + argCount = *c.request.argumentCount } bestIndex := c.getLongestCandidateIndex(candidates, argCount) candidate := candidates[bestIndex] @@ -10240,7 +10675,7 @@ func (c *Checker) invocationErrorDetails(errorTarget *ast.Node, apparentType *Ty headMessage := core.IfElse(isCall, diagnostics.This_expression_is_not_callable, diagnostics.This_expression_is_not_constructable) // Diagnose get accessors incorrectly called as functions if ast.IsCallExpression(errorTarget.Parent) && len(errorTarget.Parent.Arguments()) == 0 { - resolvedSymbol := c.getResolvedSymbolOrNil(errorTarget) + resolvedSymbol := c.symbolOfCheckedExpression(errorTarget) if resolvedSymbol != nil && resolvedSymbol.Flags()&ast.SymbolFlagsGetAccessor != 0 { headMessage = diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without } @@ -10385,14 +10820,16 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethod(node *ast.Node, c // Return plain anyFunctionType if there is no possibility we'll make inferences from the return type contextualSignature := c.getContextualSignature(node) if contextualSignature != nil && c.couldContainTypeVariables(c.getReturnTypeOfSignature(contextualSignature)) { - if cached, ok := c.contextFreeTypes[node]; ok { + if cached, ok := c.contextFreeTypes.cached(c, node); ok { return cached } + c.contextFreeTypes.begin(c, node) returnType := c.getReturnTypeFromBody(node, checkMode) returnOnlySignature := c.newSignature(SignatureFlagsIsNonInferrable, nil, nil /*typeParameters*/, nil /*thisParameter*/, nil, returnType, nil /*resolvedTypePredicate*/, 0) returnOnlyType := c.newAnonymousType(node.Symbol(), nil, []*Signature{returnOnlySignature}, nil, nil) returnOnlyType.objectFlags |= ObjectFlagsNonInferrableType - c.contextFreeTypes[node] = returnOnlyType + c.contextFreeTypes.set(c, node, returnOnlyType) + c.endMemo() return returnOnlyType } } @@ -10413,19 +10850,81 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethod(node *ast.Node, c } func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node *ast.Node, checkMode CheckMode) { + c.assignContextualParameterTypesOfFunction(node, checkMode) + key := memoKeyOf(node, memoContextChecked) + // A check in progress below a cycle yield is hidden, so the function is + // checked again as if it were not, as computing from scratch would. + i, ok := c.resolvingGet(key) + hidden := ok && int(i) < c.visibleStart + c.beginMemo(key) + c.contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncached(node, checkMode, hidden) + c.endMemo() +} + +func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncached(node *ast.Node, checkMode CheckMode, hidden bool) { + links := c.nodeLinks.Get(node) + if links.flags&NodeCheckFlagsContextChecked == 0 || links.flags&NodeCheckFlagsSignatureContextChecked != 0 && !hidden { + return + } + // The flag guards against checking the function again from within the + // check, so it is set now, and is only discarded if a cycle in progress + // logs it. + markerLogged := c.logResults() + setFlagMemoBits(c, memoKeyOf(node, memoContextChecked), &links.flags, NodeCheckFlagsSignatureContextChecked, NodeCheckFlagsSignatureContextChecked) + signature := c.getSignatureFromDeclarationUncontextual(node) + contextualSignature := c.getContextualSignature(node) + // The return type is inferred now, while the contextual types of the + // function's enclosing expressions are in place; a later request may + // come from where they are not. + if contextualSignature != nil && c.getReturnTypeFromAnnotation(node) == nil && signature.resolvedReturnType.cached(c) == nil && !c.isResolvingReturnTypeOfSignature(signature) { + // resolvedReturnType is cached indefinitely, so the return type here has to be computed without CheckModeSkipContextSensitive; + // otherwise anyFunctionType could leak as part of the computed (and cached) return type. + returnType := c.getReturnTypeFromBody(node, checkMode&^CheckModeSkipContextSensitive) + if signature.resolvedReturnType.cached(c) == nil { + if markerLogged { + signature.resolvedReturnType.set(c, returnType) + } else { + // A cycle detected since the flag was set would discard the + // return type but keep the flag, so a later request would + // infer the return type without the contextual types in + // place now. Keep the return type with the flag instead. + signature.resolvedReturnType.setIdentity(c, returnType) + } + } + } + c.checkSignatureDeclaration(node) +} + +// assignContextualParameterTypesOfFunction assigns the parameters of a +// function expression or object literal method their contextual types, and +// its signature the type parameters of a generic contextual signature. The +// signature of the function is not complete until then, so +// getSignatureFromDeclaration requests this before returning it. +func (c *Checker) assignContextualParameterTypesOfFunction(node *ast.Node, checkMode CheckMode) { + c.beginMemo(memoKeyOf(node, memoContextualParameters)) + c.assignContextualParameterTypesOfFunctionUncached(node, checkMode) + c.endMemo() +} + +func (c *Checker) assignContextualParameterTypesOfFunctionUncached(node *ast.Node, checkMode CheckMode) { links := c.nodeLinks.Get(node) - // Check if function expression is contextually typed and assign parameter types if so. if links.flags&NodeCheckFlagsContextChecked == 0 { contextualSignature := c.getContextualSignature(node) // If a type check is started at a function expression that is an argument of a function call, obtaining the // contextual type may recursively get back to here during overload resolution of the call. If so, we will have // already assigned contextual types. if links.flags&NodeCheckFlagsContextChecked == 0 { - links.flags |= NodeCheckFlagsContextChecked - signature := core.FirstOrNil(c.getSignaturesOfType(c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)), SignatureKindCall)) + // The flag guards against assigning the parameter types again + // from within the assignment, so it is set now. + flagLogged := c.logResults() + setFlagMemoBits(c, memoKeyOf(node, memoContextualParameters), &links.flags, NodeCheckFlagsContextChecked, NodeCheckFlagsContextChecked) + // A JSDoc @type tag on the function supplies the signature of its + // symbol, and the types of its parameters. + signature := c.getSignatureOfFullSignatureType(node) if signature == nil { - return + signature = c.getSignatureFromDeclarationUncontextual(node) } + c.beginTypeResolution(node, TypeSystemPropertyNameContextChecked, nil) if c.isContextSensitive(node) { if contextualSignature != nil { inferenceContext := c.getInferenceContext(node) @@ -10455,20 +10954,23 @@ func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node c.inferFromAnnotatedParametersAndReturn(signature, contextualSignature, inferenceContext) } } - if contextualSignature != nil && c.getReturnTypeFromAnnotation(node) == nil && signature.resolvedReturnType == nil { - // resolvedReturnType is cached indefinitely, so the return type here has to be computed without CheckModeSkipContextSensitive; - // otherwise anyFunctionType could leak as part of the computed (and cached) return type. - returnType := c.getReturnTypeFromBody(node, checkMode&^CheckModeSkipContextSensitive) - if signature.resolvedReturnType == nil { - signature.resolvedReturnType = returnType - } + c.popTypeResolution() + if !flagLogged && c.logResults() { + // A cycle detected since the flag was set discards the + // parameter types assigned since. The flag is discarded with + // them, so that they are assigned again. + c.logMemoDiscard(nil, memoKeyOf(node, memoContextualParameters), func() { links.flags &^= NodeCheckFlagsContextChecked }) } - c.checkSignatureDeclaration(node) + return } } + c.observeResolutionInProgress(node, TypeSystemPropertyNameContextChecked) } func (c *Checker) checkFunctionExpressionOrObjectLiteralMethodDeferred(node *ast.Node) { + // Account for the contextual check of the function, which may have been + // performed by a query rather than by resolving the enclosing call. + c.contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, CheckModeNormal) functionFlags := ast.GetFunctionFlags(node) returnType := c.getReturnTypeFromAnnotation(node) c.checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType) @@ -10617,6 +11119,9 @@ func (c *Checker) assignContextualParameterTypes(sig *Signature, context *Signat // This signature has already has a contextual inference performed and cached on it return } + if c.logResults() { + c.logRestore(func() { sig.setTypeParameters(c, nil) }) + } sig.setTypeParameters(c, context.TypeParameters()) } if context.ThisParameter() != nil { @@ -10629,23 +11134,11 @@ func (c *Checker) assignContextualParameterTypes(sig *Signature, context *Signat } } length := len(sig.parameters) - core.IfElse(signatureHasRestParameter(sig), 1, 0) + c.contextualParameterAssignments = append(c.contextualParameterAssignments, contextualParameterAssignment{sig, context}) for i := range length { - parameter := sig.parameters[i] - declaration := parameter.ValueDeclaration() - if declaration.Type() == nil { - t := c.tryGetTypeAtPosition(context, i) - if t != nil && declaration.Initializer() != nil { - initializerType := c.checkDeclarationInitializer(declaration, CheckModeNormal, nil) - if !c.isTypeAssignableTo(initializerType, t) { - initializerType = c.widenTypeInferredFromInitializer(declaration, initializerType) - if c.isTypeAssignableTo(t, initializerType) { - t = initializerType - } - } - } - c.assignParameterType(parameter, t) - } + c.assignContextualParameterType(sig, context, i) } + c.contextualParameterAssignments = c.contextualParameterAssignments[:len(c.contextualParameterAssignments)-1] if signatureHasRestParameter(sig) { // parameter might be a transient symbol generated by use of `arguments` in the function body. parameter := core.LastOrNil(sig.parameters) @@ -10657,18 +11150,72 @@ func (c *Checker) assignContextualParameterTypes(sig *Signature, context *Signat } } -func (c *Checker) assignNonContextualParameterTypes(signature *Signature) { - if signature.ThisParameter() != nil { - c.assignParameterType(signature.ThisParameter(), nil) - } - for _, parameter := range signature.parameters { - c.assignParameterType(parameter, nil) - } +// A contextualParameterAssignment is the assignment of the contextual +// parameter types of a signature in progress. +type contextualParameterAssignment struct { + signature *Signature + context *Signature +} + +// assignContextualParameterType assigns the parameter at index i of sig its +// type from the contextual signature, unless it is annotated or already +// being assigned. The type depends only on the parameter's own declaration, +// so a parameter read while the parameters before it are assigned is +// assigned first; see getTypeOfVariableOrParameterOrProperty. +func (c *Checker) assignContextualParameterType(sig *Signature, context *Signature, i int) { + parameter := sig.parameters[i] + declaration := parameter.ValueDeclaration() + if declaration.Type() != nil || slices.Contains(c.parametersAssigning, parameter) { + return + } + c.parametersAssigning = append(c.parametersAssigning, parameter) + t := c.tryGetTypeAtPosition(context, i) + if t != nil && declaration.Initializer() != nil { + initializerType := c.checkDeclarationInitializer(declaration, CheckModeNormal, nil) + if !c.isTypeAssignableTo(initializerType, t) { + initializerType = c.widenTypeInferredFromInitializer(declaration, initializerType) + if c.isTypeAssignableTo(t, initializerType) { + t = initializerType + } + } + } + c.assignParameterType(parameter, t) + c.parametersAssigning = c.parametersAssigning[:len(c.parametersAssigning)-1] +} + +// assignContextualParameterTypeInProgress assigns the parameter of fn +// declaring symbol, or one of its binding elements, its contextual type, +// while the contextual parameter types of fn are being assigned. +func (c *Checker) assignContextualParameterTypeInProgress(fn *ast.Node, symbol *ast.Symbol) { + decl := symbol.ValueDeclaration() + if ast.IsBindingElement(decl) { + decl = ast.WalkUpBindingElementsAndPatterns(decl) + } + for _, a := range slices.Backward(c.contextualParameterAssignments) { + if a.signature.declaration == fn { + length := len(a.signature.parameters) - core.IfElse(signatureHasRestParameter(a.signature), 1, 0) + for i, parameter := range a.signature.parameters[:length] { + if parameter.ValueDeclaration() == decl { + c.assignContextualParameterType(a.signature, a.context, i) + } + } + return + } + } +} + +func (c *Checker) assignNonContextualParameterTypes(signature *Signature) { + if signature.ThisParameter() != nil { + c.assignParameterType(signature.ThisParameter(), nil) + } + for _, parameter := range signature.parameters { + c.assignParameterType(parameter, nil) + } } func (c *Checker) assignParameterType(parameter *ast.Symbol, contextualType *Type) { links := c.valueSymbolLinks.Get(parameter) - if links.resolvedType != nil { + if links.resolvedType.cached(c) != nil { return } declaration := parameter.ValueDeclaration() @@ -10680,13 +11227,13 @@ func (c *Checker) assignParameterType(parameter *ast.Symbol, contextualType *Typ t = c.getTypeOfSymbol(parameter) } } - links.resolvedType = c.addOptionalityEx(t, false, declaration != nil && declaration.Initializer() == nil && isOptionalDeclaration(declaration)) + links.resolvedType.set(c, c.addOptionalityEx(t, false, declaration != nil && declaration.Initializer() == nil && isOptionalDeclaration(declaration))) if declaration != nil && !ast.IsIdentifier(declaration.Name()) { // if inference didn't come up with anything but unknown, fall back to the binding pattern if present. - if links.resolvedType == c.unknownType { - links.resolvedType = c.getTypeFromBindingPattern(declaration.Name(), false, false) + if links.resolvedType.cached(c) == c.unknownType { + links.resolvedType.set(c, c.getTypeFromBindingPattern(declaration.Name(), false, false)) } - c.assignBindingElementTypes(declaration.Name(), links.resolvedType) + c.assignBindingElementTypes(declaration.Name(), links.resolvedType.cached(c)) } } @@ -10698,7 +11245,7 @@ func (c *Checker) assignBindingElementTypes(pattern *ast.Node, parentType *Type) if name != nil { t := c.getBindingElementTypeFromParentType(element, parentType, false /*noTupleBoundsCheck*/) if ast.IsIdentifier(name) { - c.valueSymbolLinks.Get(c.getSymbolOfDeclaration(element)).resolvedType = t + c.valueSymbolLinks.Get(c.getSymbolOfDeclaration(element)).resolvedType.set(c, t) } else { c.assignBindingElementTypes(name, t) } @@ -10804,7 +11351,7 @@ func (c *Checker) setNodeLinksForPrivateIdentifierScope(node *ast.Node) { func (c *Checker) recordPotentialCollisionWithWeakMapSetInGeneratedCode(node *ast.Node, name *ast.Node) { if c.languageVersion <= core.ScriptTargetES2021 && (c.needCollisionCheckForIdentifier(node, name, "WeakMap") || c.needCollisionCheckForIdentifier(node, name, "WeakSet")) { - c.addDeferredDiagnostic(func() { + c.addDeferredDiagnostic(func(c *Checker) { c.checkWeakMapSetCollision(node) }) } @@ -10838,7 +11385,7 @@ func (c *Checker) checkCollisionWithGlobalPromiseInGeneratedCode(node *ast.Node, func (c *Checker) recordPotentialCollisionWithReflectInGeneratedCode(node *ast.Node, name *ast.Node) { if name != nil && c.languageVersion <= core.ScriptTargetES2021 && c.needCollisionCheckForIdentifier(node, name, "Reflect") { - c.addDeferredDiagnostic(func() { + c.addDeferredDiagnostic(func(c *Checker) { c.checkReflectCollision(node) }) } @@ -10928,9 +11475,26 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node) return exprType } key := InstantiationExpressionKey{nodeId: ast.GetNodeId(node), typeId: exprType.id} - if cached := c.instantiationExpressionTypes[key]; cached != nil { - return cached - } + entry, _ := c.instantiationExpressionTypes.get(key) + if entry == nil { + entry = &instantiationExpressionEntry{} + c.instantiationExpressionTypes.intern(key, entry) + } + if entry.t != nil { + c.observeFlagMemo(memoKeyOf(entry, memoInstantiationExpressionType)) + return entry.t + } + c.beginMemo(memoKeyOf(entry, memoInstantiationExpressionType)) + result := c.getInstantiationExpressionTypeUncached(exprType, node, typeArguments, entry) + c.endMemo() + return result +} + +type instantiationExpressionEntry struct { + t *Type +} + +func (c *Checker) getInstantiationExpressionTypeUncached(exprType *Type, node *ast.Node, typeArguments *ast.NodeList, entry *instantiationExpressionEntry) *Type { hasSomeApplicableSignature := false var nonApplicableType *Type getInstantiatedSignatures := func(signatures []*Signature) []*Signature { @@ -10938,11 +11502,15 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node) return len(sig.TypeParameters()) != 0 && c.hasCorrectTypeArgumentArity(sig, typeArguments.Nodes) }) return core.SameMap(applicableSignatures, func(sig *Signature) *Signature { - typeArgumentTypes := c.checkTypeArguments(sig, typeArguments.Nodes, true /*reportErrors*/, nil) - if typeArgumentTypes != nil { - return c.getSignatureInstantiation(sig, typeArgumentTypes, ast.IsInJSFile(sig.declaration), nil) - } - return sig + // As for a type reference, the type arguments are those given + // whether or not they satisfy their constraints, which are + // checked once the types they need are resolved: checking them + // can need the variances of a type whose members include this + // expression. + c.addDeferredDiagnostic(func(c *Checker) { + c.checkTypeArguments(sig, typeArguments.Nodes, true /*reportErrors*/, nil) + }) + return c.getSignatureInstantiation(sig, core.Map(typeArguments.Nodes, c.getTypeFromTypeNode), ast.IsInJSFile(sig.declaration), nil) }) } var getInstantiatedType func(*Type) *Type @@ -10962,7 +11530,7 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node) debug.Assert(t.symbol != nil, "Instantiation expression source type must have a symbol") symbol.SetDeclarations(t.symbol.Declarations()) result := c.newObjectType(ObjectFlagsAnonymous|ObjectFlagsInstantiationExpressionType, symbol) - c.setStructuredTypeMembers(result, resolved.getMembers(), callSignatures, constructSignatures, resolved.getIndexInfos()) + c.setStructuredTypeMembers(result, resolved.getMembers(c), callSignatures, constructSignatures, resolved.getIndexInfos()) result.AsInstantiationExpressionType().node = node return result } @@ -10991,7 +11559,7 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node) return result } result := getInstantiatedType(exprType) - c.instantiationExpressionTypes[key] = result + c.setFlagMemoValue(memoKeyOf(entry, memoInstantiationExpressionType), &entry.t, result) var errorType *Type if hasSomeApplicableSignature { errorType = nonApplicableType @@ -11081,7 +11649,7 @@ func (c *Checker) checkDeleteExpression(node *ast.Node) *Type { if ast.IsPropertyAccessExpression(expr) && ast.IsPrivateIdentifier(expr.Name()) { c.error(expr, diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier) } - symbol := c.getExportSymbolOfValueSymbolIfExported(c.getResolvedSymbolOrNil(expr)) + symbol := c.getExportSymbolOfValueSymbolIfExported(c.symbolOfCheckedExpression(expr)) if symbol != nil { if c.isReadonlySymbol(symbol) { c.error(expr, diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property) @@ -11337,8 +11905,9 @@ func (c *Checker) checkIdentifier(node *ast.Node, checkMode CheckMode) *Type { // If the identifier is declared in a binding pattern for which we're currently computing the implied type and the // reference occurs with the same binding pattern, return the non-inferrable any type. This for example occurs in // 'const [a, b = a + 1] = [2]' when we're computing the contextual type for the array literal '[2]'. - if declaration != nil && declaration.Kind == ast.KindBindingElement && slices.Contains(c.contextualBindingPatterns, declaration.Parent) && - ast.FindAncestor(node, func(parent *ast.Node) bool { return parent == declaration.Parent }) != nil { + if declaration != nil && declaration.Kind == ast.KindBindingElement && + ast.FindAncestor(node, func(parent *ast.Node) bool { return parent == declaration.Parent }) != nil && + c.isResolvingAnywhere(declaration.Parent, TypeSystemPropertyNameContextualBindingPattern) { return c.nonInferrableAnyType } t := c.getNarrowedTypeOfSymbol(localOrExportSymbol, node) @@ -11487,9 +12056,16 @@ func (c *Checker) removeOptionalityFromDeclaredType(declaredType *Type, declarat } func (c *Checker) parameterInitializerContainsUndefined(declaration *ast.Node) bool { + c.beginMemo(memoKeyOf(declaration, memoInitializerIsUndefined)) + result := c.parameterInitializerContainsUndefinedUncached(declaration) + c.endMemo() + return result +} + +func (c *Checker) parameterInitializerContainsUndefinedUncached(declaration *ast.Node) bool { links := c.nodeLinks.Get(declaration) if links.flags&NodeCheckFlagsInitializerIsUndefinedComputed == 0 { - if !c.pushTypeResolution(declaration, TypeSystemPropertyNameInitializerIsUndefined) { + if !c.pushTypeResolution(declaration, TypeSystemPropertyNameInitializerIsUndefined, nil) { c.reportCircularityError(declaration.Symbol()) return true } @@ -11499,7 +12075,7 @@ func (c *Checker) parameterInitializerContainsUndefined(declaration *ast.Node) b return true } if links.flags&NodeCheckFlagsInitializerIsUndefinedComputed == 0 { - links.flags |= NodeCheckFlagsInitializerIsUndefinedComputed | core.IfElse(containsUndefined, NodeCheckFlagsInitializerIsUndefined, 0) + setFlagMemoBits(c, memoKeyOf(declaration, memoInitializerIsUndefined), &links.flags, NodeCheckFlagsInitializerIsUndefinedComputed|NodeCheckFlagsInitializerIsUndefined, NodeCheckFlagsInitializerIsUndefinedComputed|core.IfElse(containsUndefined, NodeCheckFlagsInitializerIsUndefined, 0)) } } return links.flags&NodeCheckFlagsInitializerIsUndefined != 0 @@ -11526,7 +12102,7 @@ func (c *Checker) checkPropertyAccessChain(node *ast.Node, checkMode CheckMode) } func (c *Checker) checkPropertyAccessExpressionOrQualifiedName(node *ast.Node, left *ast.Node, leftType *Type, right *ast.Node, checkMode CheckMode, writeOnly bool) *Type { - parentSymbol := c.getResolvedSymbolOrNil(left) + parentSymbol := c.symbolOfCheckedExpression(left) assignmentKind := getAssignmentTargetKind(node) widenedType := leftType if assignmentKind != AssignmentKindNone || c.isMethodAccessForCall(node) { @@ -11614,7 +12190,7 @@ func (c *Checker) checkPropertyAccessExpressionOrQualifiedName(node *ast.Node, l return c.anyType } if right.Text() != "" && !c.checkAndReportErrorForExtendingInterface(node) { - c.addDeferredDiagnostic(func() { + c.addDeferredDiagnostic(func(c *Checker) { // must be deferred because reporting this error can cause us to materialize the containing type completely (to print it), leading to erroneous circularity errors c.reportNonexistentProperty(right, core.IfElse(isThisTypeParameter(leftType), apparentType, leftType), isUncheckedJS) }) @@ -11641,7 +12217,7 @@ func (c *Checker) checkPropertyAccessExpressionOrQualifiedName(node *ast.Node, l } c.checkPropertyNotUsedBeforeDeclaration(prop, node, right) c.markPropertyAsReferenced(prop, node, c.isSelfTypeAccess(left, parentSymbol)) - c.symbolNodeLinks.Get(node).resolvedSymbol = prop + setIfChanged(c, &c.symbolNodeLinks.Get(node).resolvedSymbol, prop) c.checkPropertyAccessibility(node, left.Kind == ast.KindSuperKeyword, ast.IsWriteAccess(node), apparentType, prop) if c.isAssignmentToReadonlyEntity(node, prop, assignmentKind) { c.error(right, diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, right.Text()) @@ -11799,19 +12375,40 @@ func (c *Checker) checkPrivateIdentifierPropertyAccess(leftType *Type, right *as } func (c *Checker) reportNonexistentProperty(propNode *ast.Node, containingType *Type, isUncheckedJS bool) { - key := NonExistentPropertyKey{propNode, containingType, isUncheckedJS} - if c.nonExistentProperties.Has(key) { + if !c.checking { + c.recordEffect(func(c *Checker) { c.reportNonexistentProperty(propNode, containingType, isUncheckedJS) }) + return + } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.reportNonexistentProperty(propNode, containingType, isUncheckedJS) }) + return + } + // The diagnostic would never be reported, and building it prints types, + // which in unchecked code can infer return types that report more of + // them. + if c.program.SkipTypeChecking(ast.GetSourceFileOfNode(propNode), false) { return } - c.nonExistentProperties.Add(key) - links := c.nodeLinks.Get(propNode) - if links.flags&NodeCheckFlagsTypeChecked != 0 { - return // error already made/in progress + // Only the first report for a name is made, even if it is reported again + // on another containing type. + if c.nonExistentPropertyNodes.Has(propNode) { + return } - links.flags |= NodeCheckFlagsTypeChecked + c.nonExistentPropertyNodes.Add(propNode) if ast.IsJSDocNameReferenceContext(propNode) { return } + // Building the diagnostic prints types and looks up suggestions, which + // can reach computations in progress, so it waits for the end of the + // check in progress, outside the computations reporting it, whether + // checking or a query reached it. + c.addDeferredDiagnostic(func(c *Checker) { + diagnostic := c.getNonexistentPropertyDiagnostic(propNode, containingType, isUncheckedJS) + c.addErrorOrSuggestion(!isUncheckedJS || diagnostic.Code() != diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.Code(), diagnostic) + }) +} + +func (c *Checker) getNonexistentPropertyDiagnostic(propNode *ast.Node, containingType *Type, isUncheckedJS bool) *ast.Diagnostic { var diagnostic *ast.Diagnostic if !ast.IsPrivateIdentifier(propNode) && containingType.flags&TypeFlagsUnion != 0 && containingType.flags&TypeFlagsPrimitive == 0 { for _, subtype := range containingType.Types() { @@ -11858,7 +12455,7 @@ func (c *Checker) reportNonexistentProperty(propNode *ast.Node, containingType * } } } - c.addErrorOrSuggestion(!isUncheckedJS || diagnostic.Code() != diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.Code(), diagnostic) + return diagnostic } func (c *Checker) getSuggestedLibForNonExistentProperty(missingProperty string, containingType *Type) string { @@ -12568,26 +13165,46 @@ func (c *Checker) checkAssertion(node *ast.Node, checkMode CheckMode) *Type { } } typeNode := node.Type() - exprType := c.checkExpressionEx(node.Expression(), checkMode) + isConst := isConstTypeReference(typeNode) + var exprType *Type + if isConst { + exprType = c.checkExpressionEx(node.Expression(), checkMode) + } else if !c.isResolvingAnywhere(node, TypeSystemPropertyNameAssertionOperand) { + // Only the deferred check uses the operand type, and it uses the + // cached one, so compute that here rather than checking twice. The + // operand is contextually typed by the asserted type alone; hiding + // any inference in progress for an enclosing call keeps the cached + // type the same as when the deferred check computes it. Computing + // the cached type sets aside any flow analysis in progress, so the + // assertion is re-entered when the operand's flow type depends on + // a call containing it within a loop; the enclosing computation + // then provides the cached type. + c.beginTypeResolution(node, TypeSystemPropertyNameAssertionOperand, nil) + c.pushInferenceContext(node.Expression(), nil) + c.checkExpressionCached(node.Expression()) + c.popInferenceContext() + c.popTypeResolution() + } // Always check the type node so its identifiers are resolved. resolveName knows not // to resolve (or report an error for) the `const` in a `const` assertion, so this is // safe even for `x as const` and keeps diagnostics stable regardless of traversal order. c.checkSourceElement(typeNode) - if isConstTypeReference(typeNode) { + if isConst { if !c.isValidConstAssertionArgument(node.Expression()) { c.error(node.Expression(), diagnostics.A_const_assertion_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals) } return c.getRegularTypeOfLiteralType(exprType) } - links := c.assertionLinks.Get(node) - links.exprType = exprType c.checkNodeDeferred(node) return c.getTypeFromTypeNode(typeNode) } func (c *Checker) checkAssertionDeferred(node *ast.Node) { typeNode := node.Type() - exprType := c.getRegularTypeOfObjectLiteral(c.getBaseTypeOfLiteralType(c.assertionLinks.Get(node).exprType)) + // The operand is checked in whatever mode the assertion was, so the + // deferred check uses its type in normal mode, which does not depend on + // which of those checks happened last. + exprType := c.getRegularTypeOfObjectLiteral(c.getBaseTypeOfLiteralType(c.checkExpressionCached(node.Expression()))) targetType := c.getTypeFromTypeNode(typeNode) if !c.isErrorType(targetType) { widenedType := c.getWidenedType(exprType) @@ -12915,6 +13532,14 @@ func (c *Checker) checkObjectLiteralDestructuringPropertyAssignment(node *ast.No return c.checkDestructuringAssignment(property.Expression(), t, CheckModeNormal, false) } c.error(property, diagnostics.Property_assignment_expected) + // The member is still checked as it would be in an object literal, as + // it is when anything computes the type of the literal. + switch property.Kind { + case ast.KindMethodDeclaration: + c.checkObjectLiteralMethod(property, CheckModeNormal) + case ast.KindGetAccessor, ast.KindSetAccessor: + c.checkNodeDeferred(property) + } return nil } @@ -13036,7 +13661,7 @@ func (c *Checker) checkAssignmentOperator(left *ast.Node, operator ast.Kind, rig if ast.IsAssignmentOperator(operator) { // We ignore assignments of undefined to CommonJS exports when there are multiple assignment declarations if ast.IsDeclarationNode(left.Parent) && ast.GetAssignmentDeclarationKind(left.Parent) == ast.JSDeclarationKindExportsProperty { - if symbol := c.symbolNodeLinks.Get(left).resolvedSymbol; symbol != nil && len(symbol.Declarations()) > 1 && rightType.flags&TypeFlagsUndefined != 0 { + if symbol := c.symbolOfCheckedExpression(left); symbol != nil && len(symbol.Declarations()) > 1 && rightType.flags&TypeFlagsUndefined != 0 { return } } @@ -13364,7 +13989,7 @@ func (c *Checker) checkInExpression(left *ast.Expression, right *ast.Expression, } // Unlike in 'checkPrivateIdentifierExpression' we now have access to the RHS type // which provides us with the opportunity to emit more detailed errors - if c.symbolNodeLinks.Get(left).resolvedSymbol == nil && ast.GetContainingClass(left) != nil { + if c.getSymbolForPrivateIdentifierExpression(left) == nil && ast.GetContainingClass(left) != nil { isUncheckedJS := c.isUncheckedJSSuggestion(left, rightType.symbol, true /*excludeClasses*/) c.reportNonexistentProperty(left, rightType, isUncheckedJS) } @@ -13445,7 +14070,7 @@ func (c *Checker) checkObjectLiteral(node *ast.Node, checkMode CheckMode) *Type contextualType := c.getApparentTypeOfContextualType(node, ContextFlagsNone) var contextualTypeHasPattern bool if contextualType != nil { - if pattern := c.patternForType[contextualType]; pattern != nil && (ast.IsObjectBindingPattern(pattern) || ast.IsObjectLiteralExpression(pattern)) { + if pattern, _ := c.patternForType.get(contextualType); pattern != nil && (ast.IsObjectBindingPattern(pattern) || ast.IsObjectLiteralExpression(pattern)) { contextualTypeHasPattern = true } } @@ -13480,17 +14105,25 @@ func (c *Checker) checkObjectLiteral(node *ast.Node, checkMode CheckMode) *Type if hasComputedSymbolProperty { indexInfos = append(indexInfos, c.getObjectLiteralIndexInfo(isReadonly, propertiesArray[offset:], c.esSymbolType)) } - result := c.newAnonymousType(node.Symbol(), propertiesTable, nil, nil, indexInfos) - result.objectFlags |= objectFlags | ObjectFlagsObjectLiteral | ObjectFlagsContainsObjectOrArrayLiteral + flags := objectFlags | ObjectFlagsObjectLiteral | ObjectFlagsContainsObjectOrArrayLiteral if contextualType == nil && ast.IsInJSFile(node) && !ast.IsInJsonFile(node) { - result.objectFlags |= ObjectFlagsJSLiteral + flags |= ObjectFlagsJSLiteral } if patternWithComputedProperties { - result.objectFlags |= ObjectFlagsObjectLiteralPatternWithComputedProperties + flags |= ObjectFlagsObjectLiteralPatternWithComputedProperties + } + existingTypes, _ := c.objectLiteralTypes.get(node) + for _, existing := range existingTypes { + if c.isSameObjectLiteralType(existing, flags, propertiesTable, indexInfos) { + return existing.t + } } + result := c.newAnonymousType(node.Symbol(), propertiesTable, nil, nil, indexInfos) + result.objectFlags |= flags if inDestructuringPattern { - c.patternForType[result] = node + c.patternForType.intern(result, node) } + c.objectLiteralTypes.intern(node, append(existingTypes, objectLiteralType{flags, propertiesTable, indexInfos, result})) return result } for _, memberDecl := range node.Properties() { @@ -13541,7 +14174,7 @@ func (c *Checker) checkObjectLiteral(node *ast.Node, checkMode CheckMode) *Type prop.SetDeclarations(member.Declarations()) prop.SetParent(member.Parent()) prop.SetValueDeclaration(member.ValueDeclaration()) - links.resolvedType = t + links.resolvedType.setIdentity(c, t) links.target = member member = prop if allPropertiesTable != nil { @@ -13724,6 +14357,25 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj } return c.getIntersectionType([]*Type{left, right}) } + var b keyBuilder + b.writeType(left) + b.writeType(right) + if symbol != nil { + b.writeByte(1) + b.writeSymbol(symbol) + } else { + b.writeByte(0) + } + b.writeUint32(uint32(objectFlags)) + if readonly { + b.writeByte(1) + } else { + b.writeByte(0) + } + key := b.hash() + if existing, _ := c.spreadTypes.cached(c, key); existing != nil { + return existing + } members := ast.NewSymbolTable() var skippedPrivateMembers collections.Set[string] var indexInfos []*IndexInfo @@ -13748,6 +14400,11 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj rightProp := members.Get(leftProp.Name()) rightType := c.getTypeOfSymbol(rightProp) if rightProp.Flags()&ast.SymbolFlagsOptional != 0 { + key := spreadSymbolKey{left: leftProp, right: rightProp} + if existing, _ := c.spreadSymbols.cached(c, key); existing != nil { + members.Set(leftProp.Name(), existing) + continue + } declarations := core.Concatenate(leftProp.Declarations(), rightProp.Declarations()) flags := ast.SymbolFlagsProperty | (leftProp.Flags() & ast.SymbolFlagsOptional) result := c.newSymbol(flags, leftProp.Name()) @@ -13760,14 +14417,15 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj leftTypeWithoutUndefined := c.removeMissingOrUndefinedType(leftType) rightTypeWithoutUndefined := c.removeMissingOrUndefinedType(rightType) if leftTypeWithoutUndefined == rightTypeWithoutUndefined { - links.resolvedType = leftType + links.resolvedType.setIdentity(c, leftType) } else { - links.resolvedType = c.getUnionTypeEx([]*Type{leftType, rightTypeWithoutUndefined}, UnionReductionSubtype, nil, nil) + links.resolvedType.setIdentity(c, c.getUnionTypeEx([]*Type{leftType, rightTypeWithoutUndefined}, UnionReductionSubtype, nil, nil)) } c.spreadLinks.Get(result).leftSpread = leftProp c.spreadLinks.Get(result).rightSpread = rightProp result.SetDeclarations(declarations) links.setNameType(c, c.valueSymbolLinks.Get(leftProp).getNameType()) + c.spreadSymbols.set(c, key, result) members.Set(leftProp.Name(), result) } } else { @@ -13777,8 +14435,18 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj spreadIndexInfos := core.SameMap(indexInfos, func(info *IndexInfo) *IndexInfo { return c.getIndexInfoWithReadonly(info, readonly) }) + flags := ObjectFlagsObjectLiteral | ObjectFlagsContainsObjectOrArrayLiteral | ObjectFlagsContainsSpread | objectFlags + // Different inputs can produce the same members, e.g. when the right side + // overrides every property of the left side. + contentKey := c.getObjectTypeContentKey(symbol, flags, members, spreadIndexInfos) + if existing, _ := c.objectContentTypes.get(contentKey); existing != nil { + c.spreadTypes.set(c, key, existing) + return existing + } spread := c.newAnonymousType(symbol, members, nil, nil, spreadIndexInfos) - spread.objectFlags |= ObjectFlagsObjectLiteral | ObjectFlagsContainsObjectOrArrayLiteral | ObjectFlagsContainsSpread | objectFlags + spread.objectFlags |= flags + c.objectContentTypes.intern(contentKey, spread) + c.spreadTypes.set(c, key, spread) return spread } @@ -13849,9 +14517,9 @@ func (c *Checker) tryMergeUnionOfObjectTypeAndEmptyObject(t *Type, readonly bool result := c.newSymbolEx(flags, prop.Name(), prop.CheckFlags()&ast.CheckFlagsLate|core.IfElse(readonly, ast.CheckFlagsReadonly, 0)) links := c.valueSymbolLinks.Get(result) if isSetonlyAccessor { - links.resolvedType = c.undefinedType + links.resolvedType.setIdentity(c, c.undefinedType) } else { - links.resolvedType = c.addOptionalityEx(c.getTypeOfSymbol(prop), true /*isProperty*/, true /*isOptional*/) + links.resolvedType.setIdentity(c, c.addOptionalityEx(c.getTypeOfSymbol(prop), true /*isProperty*/, true /*isOptional*/)) } result.SetDeclarations(prop.Declarations()) links.setNameType(c, c.valueSymbolLinks.Get(prop).getNameType()) @@ -13875,20 +14543,74 @@ func (c *Checker) getSpreadSymbol(prop *ast.Symbol, readonly bool) *ast.Symbol { if !isSetonlyAccessor && readonly == c.isReadonlySymbol(prop) { return prop } + key := spreadSymbolKey{right: prop, readonly: readonly} + if existing, _ := c.spreadSymbols.cached(c, key); existing != nil { + return existing + } flags := ast.SymbolFlagsProperty | (prop.Flags() & ast.SymbolFlagsOptional) result := c.newSymbolEx(flags, prop.Name(), prop.CheckFlags()&ast.CheckFlagsLate|core.IfElse(readonly, ast.CheckFlagsReadonly, 0)) links := c.valueSymbolLinks.Get(result) if isSetonlyAccessor { - links.resolvedType = c.undefinedType + links.resolvedType.setIdentity(c, c.undefinedType) } else { - links.resolvedType = c.getTypeOfSymbol(prop) + links.resolvedType.setIdentity(c, c.getTypeOfSymbol(prop)) } result.SetDeclarations(prop.Declarations()) links.setNameType(c, c.valueSymbolLinks.Get(prop).getNameType()) c.mappedSymbolLinks.Get(result).syntheticOrigin = prop + c.spreadSymbols.set(c, key, result) return result } +// spreadSymbolKey identifies a property symbol synthesized by a spread: either +// a copy of right with the given readonly-ness, or the merge of an optional +// right property into left. +type spreadSymbolKey struct { + left *ast.Symbol + right *ast.Symbol + readonly bool +} + +// getObjectTypeContentKey identifies the content of an object type derived +// from other object types, such as a spread, widened, or regular type. Members +// are either input properties or synthesized symbols that are themselves +// memoized, so symbol identity determines member content. +func (c *Checker) getObjectTypeContentKey(symbol *ast.Symbol, flags ObjectFlags, members ast.SymbolTable, indexInfos []*IndexInfo) CacheHashKey { + var b keyBuilder + if symbol != nil { + b.writeByte(1) + b.writeSymbol(symbol) + } else { + b.writeByte(0) + } + b.writeUint32(uint32(flags)) + b.writeInt(members.Len()) + for member := range members.Values() { + b.writeSymbol(member) + } + b.writeInt(len(indexInfos)) + for _, info := range indexInfos { + b.writeType(info.keyType) + b.writeType(info.valueType) + if info.isReadonly { + b.writeByte(1) + } else { + b.writeByte(0) + } + if info.declaration != nil { + b.writeByte(1) + b.writeNode(info.declaration) + } else { + b.writeByte(0) + } + b.writeInt(len(info.components)) + for _, n := range info.components { + b.writeNode(n) + } + } + return b.hash() +} + func (c *Checker) isEmptyObjectTypeOrSpreadsIntoEmptyObject(t *Type) bool { return c.isEmptyObjectType(t) || t.flags&(TypeFlagsNull|TypeFlagsUndefined|TypeFlagsBooleanLike|TypeFlagsNumberLike|TypeFlagsBigIntLike|TypeFlagsStringLike|TypeFlagsEnumLike|TypeFlagsNonPrimitive|TypeFlagsIndex) != 0 } @@ -14064,16 +14786,15 @@ func (c *Checker) getNarrowedTypeOfSymbol(symbol *ast.Symbol, location *ast.Node } parent := declaration.Parent.Parent if ast.IsVariableDeclaration(rootDeclaration) && c.getCombinedNodeFlagsCached(rootDeclaration)&ast.NodeFlagsConstant != 0 || ast.IsParameterDeclaration(rootDeclaration) { - links := c.nodeLinks.Get(parent) - if links.flags&NodeCheckFlagsInCheckIdentifier == 0 { - links.flags |= NodeCheckFlagsInCheckIdentifier + if !c.isResolvingAnywhere(parent, TypeSystemPropertyNameBindingElementParent) { + c.beginTypeResolution(parent, TypeSystemPropertyNameBindingElementParent, nil) parentType := c.getTypeForBindingElementParent(parent, CheckModeNormal) var parentTypeConstraint *Type if parentType != nil { parentTypeConstraint = c.mapType(parentType, c.getBaseConstraintOrType) } // Guard parent-type resolution only; flow analysis should allow re-entrant narrowing - links.flags &^= NodeCheckFlagsInCheckIdentifier + c.popTypeResolution() if parentTypeConstraint != nil && parentTypeConstraint.flags&TypeFlagsUnion != 0 && !(ast.IsParameterDeclaration(rootDeclaration) && c.isSomeSymbolAssigned(rootDeclaration)) { pattern := declaration.Parent narrowedType := c.getFlowTypeOfReferenceEx(pattern, parentTypeConstraint, parentTypeConstraint, nil /*flowContainer*/, getFlowNodeOfNode(location)) @@ -14194,26 +14915,76 @@ func (c *Checker) checkExpressionForMutableLocation(node *ast.Node, checkMode Ch func (c *Checker) getResolvedSymbol(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol == nil { + if symbol := links.resolvedSymbol.cached(c); symbol != nil { + return symbol + } + links.resolvedSymbol.begin(c) + result := c.getResolvedSymbolUncached(node) + c.endMemo() + return result +} + +func (c *Checker) getResolvedSymbolUncached(node *ast.Node) *ast.Symbol { + links := c.symbolNodeLinks.Get(node) + if links.resolvedSymbol.cached(c) == nil { var symbol *ast.Symbol if !ast.NodeIsMissing(node) { symbol = c.resolveName(node, node.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, c.getCannotFindNameDiagnosticForName(node), !ast.IsWriteOnlyAccess(node), false /*excludeGlobals*/) } - links.resolvedSymbol = core.OrElse(symbol, c.unknownSymbol) + links.resolvedSymbol.set(c, core.OrElse(symbol, c.unknownSymbol)) + } + return links.resolvedSymbol.cached(c) +} + +// getSymbolOfExpression returns the symbol the expression node resolves to, +// which checking it caches. Once the check of its file has found a symbol, it +// is read from there, rather than checking the expression again. +func (c *Checker) getSymbolOfExpression(node *ast.Node) *ast.Symbol { + links := c.symbolNodeLinks.Get(node) + if c.sourceFileLinks.Get(ast.GetSourceFileOfNode(node)).typeChecked { + if symbol := links.resolvedSymbol.cached(c); symbol != nil { + return symbol + } } - return links.resolvedSymbol + c.checkExpressionCached(node) + return links.resolvedSymbol.cached(c) } -func (c *Checker) getResolvedSymbolOrNil(node *ast.Node) *ast.Symbol { - return c.symbolNodeLinks.Get(node).resolvedSymbol +// getSymbolOfReferenceForEmit returns the symbol of a member access emit +// refers to. Emit resolves other names itself. +func (c *Checker) getSymbolOfReferenceForEmit(node *ast.Node) *ast.Symbol { + if ast.IsAccessExpression(node) { + return c.getSymbolOfExpression(node) + } + return nil } -func (c *Checker) getReferencedValueOrAliasSymbol(reference *ast.Node) *ast.Symbol { - resolvedSymbol := c.symbolNodeLinks.Get(reference).resolvedSymbol - if resolvedSymbol != nil && resolvedSymbol != c.unknownSymbol { - return resolvedSymbol +// symbolOfCheckedExpression returns the symbol the expression node resolved +// to when the current computation checked it. Checking it again would +// re-enter that check. +func (c *Checker) symbolOfCheckedExpression(node *ast.Node) *ast.Symbol { + return c.symbolNodeLinks.Get(node).resolvedSymbol.cached(c) +} + +// getSymbolOfTypeNode returns the symbol the type node resolves to, which +// resolving its type caches. +func (c *Checker) getSymbolOfTypeNode(node *ast.Node) *ast.Symbol { + return c.getSymbolOfTypeNodePart(node, node) +} + +// getSymbolOfTypeNodePart returns the symbol the part of the type node +// resolves to, such as a name in the qualifier of an import type, which +// resolving the type caches. +func (c *Checker) getSymbolOfTypeNodePart(typeNode *ast.Node, part *ast.Node) *ast.Symbol { + c.getTypeFromTypeNode(typeNode) + if links := c.symbolNodeLinks.TryGet(part); links != nil { + return links.resolvedSymbol.cached(c) } + return nil +} + +func (c *Checker) getReferencedValueOrAliasSymbol(reference *ast.Node) *ast.Symbol { return c.resolveName(reference, reference.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue|ast.SymbolFlagsAlias, nil, false /*isUse*/, false /*excludeGlobals*/) } @@ -14273,24 +15044,45 @@ func (c *Checker) getDiagnostics(ctx context.Context, sourceFile *ast.SourceFile func (c *Checker) GetGlobalDiagnostics() []*ast.Diagnostic { c.checkNotCanceled() - c.produceDeferredDiagnostics() + c.withChecking(c.produceDeferredDiagnostics) return c.diagnostics.GetGlobalDiagnostics() } -func (c *Checker) addDeferredDiagnostic(callback func()) { +// Deferred callbacks receive the checker that produces them, since the one +// that queued them may be a checker answering queries sharing this store. +func (c *Checker) addDeferredDiagnostic(callback func(c *Checker)) { + if !c.checking { + c.recordEffect(func(c *Checker) { c.addDeferredDiagnostic(callback) }) + return + } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.addDeferredDiagnostic(callback) }) + return + } c.deferredDiagnosticCallbacks = append(c.deferredDiagnosticCallbacks, callback) } func (c *Checker) produceDeferredDiagnostics() { - for _, cb := range c.deferredDiagnosticCallbacks { - cb() + for len(c.deferredDiagnosticCallbacks) != 0 { + callbacks := c.deferredDiagnosticCallbacks + c.deferredDiagnosticCallbacks = nil + for _, cb := range callbacks { + cb(c) + } } - c.deferredDiagnosticCallbacks = nil } func (c *Checker) addDiagnostic(diagnostic *ast.Diagnostic) *ast.Diagnostic { // Discard diagnostics created while at the maximum number of recursive TypeToString invocations. - if c.serializationLevel < maxSerializationLevel { + if !c.depthLimitReached(&c.serializationLevel, maxSerializationLevel) { + if !c.checking { + c.recordEffect(func(c *Checker) { c.diagnostics.Add(diagnostic) }) + return diagnostic + } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.diagnostics.Add(diagnostic) }) + return diagnostic + } return c.diagnostics.Add(diagnostic) } return diagnostic @@ -14298,7 +15090,15 @@ func (c *Checker) addDiagnostic(diagnostic *ast.Diagnostic) *ast.Diagnostic { func (c *Checker) addSuggestionDiagnostic(diagnostic *ast.Diagnostic) *ast.Diagnostic { // Discard diagnostics created while at the maximum number of recursive TypeToString invocations. - if c.serializationLevel < maxSerializationLevel { + if !c.depthLimitReached(&c.serializationLevel, maxSerializationLevel) { + if !c.checking { + c.recordEffect(func(c *Checker) { c.suggestionDiagnostics.Add(diagnostic) }) + return diagnostic + } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.suggestionDiagnostics.Add(diagnostic) }) + return diagnostic + } return c.suggestionDiagnostics.Add(diagnostic) } return diagnostic @@ -14308,6 +15108,50 @@ func (c *Checker) error(location *ast.Node, message *diagnostics.Message, args . return c.addDiagnostic(NewDiagnosticForNode(location, message, args...)) } +// errorAtCurrentNode reports an error at the node currently being checked. +// When a result is computed outside of checking, there is no such node; the +// location is then resolved when checking first observes the result, which +// is where the error would have been reported had checking computed it. +func (c *Checker) errorAtCurrentNode(message *diagnostics.Message, args ...any) { + c.reportAtCurrentNode(func(c *Checker, node *ast.Node) { c.error(node, message, args...) }) +} + +// reportAtCurrentNode reports an error located at whichever node's check +// reached it, so that every node reaching it reports it, as it would if it +// were checked first. Results cached from now until the current node is left +// were computed for that node, and are discarded so that other nodes +// compute them again. +func (c *Checker) reportAtCurrentNode(report func(c *Checker, node *ast.Node)) { + c.reportNode(¤tNodeError{report}) +} + +func (c *Checker) reportNode(r *currentNodeError) { + c.markCurrentNodeCircular() + if c.currentNodeErrorCollectors != 0 { + c.currentNodeErrors = append(c.currentNodeErrors, r) + } + c.reportAtCurrentNodeOnce(r.report) +} + +// reportAtCurrentNodeOnce is reportAtCurrentNode for an error whose result +// is kept, so that only the node reaching it first reports it. +func (c *Checker) reportAtCurrentNodeOnce(report func(c *Checker, node *ast.Node)) { + if !c.checking { + // A node the computation started at is where the computation was + // requested from, so it is located wherever the result is reused. + node := c.currentNode + if c.atMemoStartNode() { + node = nil + } + if c.memoTop != 0 { + c.resolutions[c.memoTop-1].reportsAtCurrentNode = true + } + c.recordEffect(func(c *Checker) { report(c, core.OrElse(node, c.currentNode)) }) + return + } + report(c, c.currentNode) +} + func (c *Checker) errorSkippedOnNoEmit(location *ast.Node, message *diagnostics.Message, args ...any) *ast.Diagnostic { diagnostic := c.error(location, message, args...) diagnostic.SetSkippedOnNoEmit() @@ -14396,13 +15240,13 @@ func (c *Checker) newSymbolEx(flags ast.SymbolFlags, name string, checkFlags ast func (c *Checker) newParameter(name string, t *Type) *ast.Symbol { symbol := c.newSymbol(ast.SymbolFlagsFunctionScopedVariable, name) - c.valueSymbolLinks.Get(symbol).resolvedType = t + c.valueSymbolLinks.Get(symbol).resolvedType.setIdentity(c, t) return symbol } func (c *Checker) newProperty(name string, t *Type) *ast.Symbol { symbol := c.newSymbol(ast.SymbolFlagsProperty, name) - c.valueSymbolLinks.Get(symbol).resolvedType = t + c.valueSymbolLinks.Get(symbol).resolvedType.setIdentity(c, t) return symbol } @@ -14413,8 +15257,18 @@ func (c *Checker) combineSymbolTables(first ast.SymbolTable, second ast.SymbolTa if second.Len() == 0 { return first } - combined := ast.NewSymbolTable() - c.mergeSymbolTable(combined, first, false, nil) + // Late binding has merged into early symbols already; the merges are + // looked up without resolving the table, whose resolution is this one. + combined := ast.NewSymbolTableWithCapacity(first.Len() + second.Len()) + for id, symbol := range first.All() { + if merged := c.mergedSymbolOf(symbol); merged != nil { + symbol = merged + } + if merged, _ := c.lateMergedSymbols.cached(c, symbol); merged != nil { + symbol = merged + } + combined.Set(id, symbol) + } c.mergeSymbolTable(combined, second, false, nil) return combined } @@ -14660,14 +15514,99 @@ func (c *Checker) cloneSymbol(symbol *ast.Symbol) *ast.Symbol { } func (c *Checker) getMergedSymbol(symbol *ast.Symbol) *ast.Symbol { - if symbol != nil { - if merged := c.mergedSymbols.TryGet(symbol); merged != nil && *merged != nil { - return *merged + if symbol == nil { + return nil + } + if merged := c.mergedSymbolOf(symbol); merged != nil { + symbol = merged + } + if symbol.Flags()&(ast.SymbolFlagsClassMember|ast.SymbolFlagsSignature) != 0 { + return c.getLateMergedSymbol(symbol) + } + return symbol +} + +// getLateMergedSymbol returns the symbol a member is merged into when its +// parent's late-bound members are resolved, resolving them if they could +// merge with the member. The answer is thus the same whether or not anything +// has resolved the parent's members yet. +func (c *Checker) getLateMergedSymbol(symbol *ast.Symbol) *ast.Symbol { + if !c.mergesFrozen || symbol.Parent() == nil { + return symbol + } + late := symbol.CheckFlags()&ast.CheckFlagsLate != 0 + var lateBindable uint8 + if !late { + // Most members cannot merge, which depends only on syntax and on + // the merges done before checking, so it is looked up cheaply. + if symbol.Parent() != c.lastLateBindableParent { + known := c.parentLateBindableKinds.Get(symbol.Parent()) + if *known == 0 { + *known = c.getLateBindableKinds(c.getMergedSymbol(symbol.Parent())) | lateBindableKnown + } + c.lastLateBindableParent = symbol.Parent() + c.lastLateBindableKinds = *known &^ lateBindableKnown + } + lateBindable = c.lastLateBindableKinds + if lateBindable == 0 { + return symbol } } + parent := c.getMergedSymbol(symbol.Parent()) + var kind MembersOrExportsResolutionKind + switch symbol { + case parent.Members().Get(symbol.Name()): + kind = MembersOrExportsResolutionKindResolvedMembers + case parent.Exports().Get(symbol.Name()): + kind = MembersOrExportsResolutionKindResolvedExports + default: + if !late { + return symbol + } + // Late-bound symbols are created by resolving their parent's members. + } + if !late { + if lateBindable&(1<= 0 { + return c.yieldMembers(key, symbol, resolutionKind, floor) + } + c.beginMemo(key) + c.currentResolution().memberSymbol = symbol + result := c.getResolvedMembersOrExportsOfSymbolUncached(symbol, resolutionKind) + c.endMemo() + return result +} + +// findEarlierMembersInCycle handles re-entering the member table of symbol, +// identified by key, while it is resolved. Re-entry observes the part of the +// table published so far, so when the tables of several symbols are resolved +// in a cycle, the result depends on which table was entered first. If the +// table of a symbol declared before this one is resolved since this table +// was entered, it returns the index in resolutions of the first declared, +// the table the cycle canonically enters at; otherwise -1. +func (c *Checker) findEarlierMembersInCycle(key memoKey, symbol *ast.Symbol) int { + i, ok := c.resolvingGet(key) + if !ok || int(i) < c.visibleStart || c.isYieldingTo(key, TypeSystemPropertyNameStructuredMembers) { + return -1 + } + for j := int(i) + 1; j < len(c.resolutions); j++ { + f := &c.resolutions[j] + if f.memberSymbol != nil && c.compareSymbols(f.memberSymbol, symbol) < 0 { + return int(i) + 1 + } + } + return -1 +} + +// yieldMembers computes the member table of symbol again, as if the cycle +// in progress had been entered at the table of a symbol declared before it: +// with the computation of the table in progress, which starts at floor, +// hidden. Re-entry observes the incomplete table, so what is computed since +// it started is in a cycle. The table in progress is the one cached once it +// is complete, so whatever computing it again caches is discarded, keeping +// only its result and effects for the caller. +func (c *Checker) yieldMembers(key memoKey, symbol *ast.Symbol, resolutionKind MembersOrExportsResolutionKind, floor int) ast.SymbolTable { + c.markCircular(floor - 1) + mark := c.markDiscard() + links := c.membersAndExportsLinks.Get(symbol) + saved := links[resolutionKind] + links[resolutionKind] = nil + c.beginCycleYield(key, TypeSystemPropertyNameStructuredMembers, -1, floor) + c.beginMemo(key) + c.currentResolution().memberSymbol = symbol + result := c.resolveMembersOrExportsOfSymbol(symbol, resolutionKind, links) + c.endMemoUncached() + c.endCycleYield() + links[resolutionKind] = saved + c.discardLogSince(mark.discardLog) + c.releaseDiscardMark(mark) + return result +} + +func (c *Checker) getResolvedMembersOrExportsOfSymbolUncached(symbol *ast.Symbol, resolutionKind MembersOrExportsResolutionKind) ast.SymbolTable { links := c.membersAndExportsLinks.Get(symbol) if links[resolutionKind] == nil { - isStatic := resolutionKind == MembersOrExportsResolutionKindResolvedExports - earlySymbols := symbol.Exports() - switch { - case !isStatic: - earlySymbols = symbol.Members() - case symbol.Flags()&ast.SymbolFlagsModule != 0: - earlySymbols, _ = c.getExportsOfModuleWorker(symbol) - } - links[resolutionKind] = earlySymbols - // fill in any as-yet-unresolved late-bound members. - var lateSymbols ast.SymbolTable - for _, decl := range symbol.Declarations() { - for _, member := range getMembersOfDeclaration(decl) { - if isStatic == ast.HasStaticModifier(member) { - switch { - case c.hasLateBindableName(member): - if lateSymbols == nil { - lateSymbols = ast.NewSymbolTable() - } - c.lateBindMember(symbol, earlySymbols, lateSymbols, member) - case c.hasLateBindableIndexSignature(member): - if lateSymbols == nil { - lateSymbols = ast.NewSymbolTable() - } - c.lateBindIndexSignature(symbol, earlySymbols, lateSymbols, member.AsNode() /* as LateBoundDeclaration | LateBoundBinaryExpressionDeclaration */) + c.resolveMembersOrExportsOfSymbol(symbol, resolutionKind, links) + if c.logResults() { + c.logMemoDiscard(nil, memoKeyOf(symbol, memoResolvedMembers+memoField(resolutionKind)), func() { links[resolutionKind] = nil }) + } + } + return links[resolutionKind] +} + +func (c *Checker) resolveMembersOrExportsOfSymbol(symbol *ast.Symbol, resolutionKind MembersOrExportsResolutionKind, links *MembersAndExportsLinks) ast.SymbolTable { + isStatic := resolutionKind == MembersOrExportsResolutionKindResolvedExports + earlySymbols := symbol.Exports() + switch { + case !isStatic: + earlySymbols = symbol.Members() + case symbol.Flags()&ast.SymbolFlagsModule != 0: + earlySymbols, _ = c.getExportsOfModuleWorker(symbol) + } + links[resolutionKind] = earlySymbols + // fill in any as-yet-unresolved late-bound members. + var lateSymbols ast.SymbolTable + for _, decl := range symbol.Declarations() { + for _, member := range getMembersOfDeclaration(decl) { + if isStatic == ast.HasStaticModifier(member) { + switch { + case c.hasLateBindableName(member): + if lateSymbols == nil { + lateSymbols = ast.NewSymbolTable() } + c.lateBindMember(symbol, earlySymbols, lateSymbols, member) + case c.hasLateBindableIndexSignature(member): + if lateSymbols == nil { + lateSymbols = ast.NewSymbolTable() + } + c.lateBindIndexSignature(symbol, earlySymbols, lateSymbols, member.AsNode() /* as LateBoundDeclaration | LateBoundBinaryExpressionDeclaration */) } } } - if isStatic { - if assignmentSymbol := symbol.Exports().Get(ast.InternalSymbolNameAssignmentDeclaration); assignmentSymbol != nil { - for _, member := range assignmentSymbol.Declarations() { - if c.hasLateBindableName(member) { - if lateSymbols == nil { - lateSymbols = ast.NewSymbolTable() - } - c.lateBindMember(symbol, earlySymbols, lateSymbols, member) + } + if isStatic { + if assignmentSymbol := symbol.Exports().Get(ast.InternalSymbolNameAssignmentDeclaration); assignmentSymbol != nil { + for _, member := range assignmentSymbol.Declarations() { + if c.hasLateBindableName(member) { + if lateSymbols == nil { + lateSymbols = ast.NewSymbolTable() } + c.lateBindMember(symbol, earlySymbols, lateSymbols, member) } } } - links[resolutionKind] = c.combineSymbolTables(earlySymbols, lateSymbols) } + links[resolutionKind] = c.combineSymbolTables(earlySymbols, lateSymbols) return links[resolutionKind] } @@ -16500,10 +17540,10 @@ func (c *Checker) getResolvedMembersOrExportsOfSymbol(symbol *ast.Symbol, resolu func (c *Checker) lateBindMember(parent *ast.Symbol, earlySymbols ast.SymbolTable, lateSymbols ast.SymbolTable, decl *ast.Node) *ast.Symbol { debug.Assert(decl.Symbol() != nil, "The member is expected to have a symbol.") links := c.symbolNodeLinks.Get(decl) - if links.resolvedSymbol == nil { + if links.resolvedSymbol.cached(c) == nil { // In the event we attempt to resolve the late-bound name of this member recursively, // fall back to the early-bound name of this member. - links.resolvedSymbol = decl.Symbol() + links.resolvedSymbol.set(c, decl.Symbol()) var declName *ast.Node if ast.IsBinaryExpression(decl) { declName = decl.AsBinaryExpression().Left @@ -16554,10 +17594,10 @@ func (c *Checker) lateBindMember(parent *ast.Symbol, earlySymbols ast.SymbolTabl if lateSymbol.Parent() == nil { lateSymbol.SetParent(parent) } - links.resolvedSymbol = lateSymbol + links.resolvedSymbol.set(c, lateSymbol) } } - return links.resolvedSymbol + return links.resolvedSymbol.cached(c) } func (c *Checker) lateBindIndexSignature(parent *ast.Symbol, earlySymbols ast.SymbolTable, lateSymbols ast.SymbolTable, decl *ast.Node) { @@ -16625,10 +17665,22 @@ func (c *Checker) getMembersOfSymbol(symbol *ast.Symbol) ast.SymbolTable { func (c *Checker) getExportsOfModule(moduleSymbol *ast.Symbol) ast.SymbolTable { links := c.moduleSymbolLinks.Get(moduleSymbol) + key := memoKeyOf(links, memoModuleExports) + if links.resolvedExports != nil && c.readsWithoutMemo(key) { + return links.resolvedExports + } + c.beginMemo(key) + result := c.getExportsOfModuleCached(moduleSymbol, links) + c.endMemo() + return result +} + +func (c *Checker) getExportsOfModuleCached(moduleSymbol *ast.Symbol, links *ModuleSymbolLinks) ast.SymbolTable { if links.resolvedExports == nil { exports, typeOnlyExportStarMap := c.getExportsOfModuleWorker(moduleSymbol) - links.resolvedExports = exports - links.typeOnlyExportStarMap = typeOnlyExportStarMap + key := memoKeyOf(links, memoModuleExports) + c.setFlagMemoValue(key, &links.typeOnlyExportStarMap, typeOnlyExportStarMap) + c.setFlagMemoValue(key, &links.resolvedExports, exports) } return links.resolvedExports } @@ -16760,12 +17812,23 @@ func (c *Checker) ResolveAlias(symbol *ast.Symbol) (*ast.Symbol, bool) { // meaning. Pure aliases are eagerly resolved and any type-only markers are back-propagated to the original // symbol. The function panics if the argument is not a symbol with an alias meaning. func (c *Checker) resolveAlias(symbol *ast.Symbol) *ast.Symbol { + links := c.aliasSymbolLinks.Get(symbol) + if target := links.aliasTarget.cached(c); target != nil { + return target + } + links.aliasTarget.begin(c) + result := c.resolveAliasUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) resolveAliasUncached(symbol *ast.Symbol) *ast.Symbol { if symbol.Flags()&ast.SymbolFlagsAlias == 0 { panic("Should only get alias here") } links := c.aliasSymbolLinks.Get(symbol) - if links.aliasTarget == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameAliasTarget) { + if links.aliasTarget.cached(c) == nil { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameAliasTarget, &links.aliasTarget.memoHeader) { return c.unknownSymbol } node := c.getDeclarationOfAliasSymbol(symbol) @@ -16777,13 +17840,13 @@ func (c *Checker) resolveAlias(symbol *ast.Symbol) *ast.Symbol { // When the target is a pure alias, we transitively resolve and propagate any typeOnlyDeclaration target = c.resolveIndirectionAlias(symbol, target) } - links.aliasTarget = core.OrElse(target, c.unknownSymbol) + links.aliasTarget.set(c, core.OrElse(target, c.unknownSymbol)) if !c.popTypeResolution() { c.error(node, diagnostics.Circular_definition_of_import_alias_0, c.symbolToString(symbol)) - links.aliasTarget = c.unknownSymbol + links.aliasTarget.set(c, c.unknownSymbol) } } - return links.aliasTarget + return links.aliasTarget.cached(c) } func (c *Checker) resolveIndirectionAlias(source *ast.Symbol, target *ast.Symbol) *ast.Symbol { @@ -16797,8 +17860,7 @@ func (c *Checker) resolveIndirectionAlias(source *ast.Symbol, target *ast.Symbol } func (c *Checker) tryResolveAlias(symbol *ast.Symbol) *ast.Symbol { - links := c.aliasSymbolLinks.Get(symbol) - if links.aliasTarget != nil || c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameAliasTarget) < 0 { + if c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameAliasTarget) < 0 { return c.resolveAlias(symbol) } return nil @@ -16896,20 +17958,20 @@ func (c *Checker) getDeclarationOfAliasSymbol(symbol *ast.Symbol) *ast.Node { func (c *Checker) getTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { deferred := c.deferredSymbolLinks.Get(symbol) if deferred.parent.flags&TypeFlagsUnion != 0 { - links.resolvedType = c.getUnionType(deferred.constituents) + links.resolvedType.set(c, c.getUnionType(deferred.constituents)) } else { - links.resolvedType = c.getIntersectionType(deferred.constituents) + links.resolvedType.set(c, c.getIntersectionType(deferred.constituents)) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { + if links.cachedWriteType(c) == nil { deferred := c.deferredSymbolLinks.Get(symbol) if len(deferred.writeConstituents) != 0 { if deferred.parent.flags&TypeFlagsUnion != 0 { @@ -16921,19 +17983,26 @@ func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type links.setWriteType(c, c.getTypeOfSymbolWithDeferredType(symbol)) } } - return links.getWriteType() + return links.cachedWriteType(c) } // Distinct write types come only from set accessors, but synthetic union and intersection // properties deriving from set accessors will either pre-compute or defer the union or // intersection of the writeTypes of their constituents. func (c *Checker) getWriteTypeOfSymbol(symbol *ast.Symbol) *Type { + c.beginMemo(memoKeyOf(symbol, memoWriteType)) + result := c.getWriteTypeOfSymbolUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getWriteTypeOfSymbolUncached(symbol *ast.Symbol) *Type { if symbol.CheckFlags()&ast.CheckFlagsSyntheticProperty != 0 { if symbol.CheckFlags()&ast.CheckFlagsDeferredType != 0 { return c.getWriteTypeOfSymbolWithDeferredType(symbol) } links := c.valueSymbolLinks.Get(symbol) - return core.OrElse(links.getWriteType(), links.resolvedType) + return core.OrElse(links.writeTypeOfCreation(), c.getTypeOfSymbol(symbol)) } if symbol.Flags()&ast.SymbolFlagsProperty != 0 { return c.removeMissingType(c.getTypeOfSymbol(symbol), symbol.Flags()&ast.SymbolFlagsOptional != 0) @@ -16966,7 +18035,7 @@ func (c *Checker) GetTypeOfSymbolAtLocation(symbol *ast.Symbol, location *ast.No } else { t = c.getTypeOfExpression(location) } - if c.getExportSymbolOfValueSymbolIfExported(c.symbolNodeLinks.Get(location).resolvedSymbol) == symbol { + if c.getExportSymbolOfValueSymbolIfExported(c.resolvedSymbolAtLocation(location, symbol)) == symbol { return c.removeOptionalTypeMarker(t) } } @@ -16986,7 +18055,30 @@ func (c *Checker) GetTypeOfSymbolAtLocation(symbol *ast.Symbol, location *ast.No return c.getNonMissingTypeOfSymbol(symbol) } +// resolvedSymbolAtLocation returns the symbol that the checked expression at +// location resolved to. Index symbols are not cached in links (see +// getSymbolOfNameOrPropertyAccessExpression), so an access that resolved to +// none is matched against the index signature it would use. +func (c *Checker) resolvedSymbolAtLocation(location *ast.Node, symbol *ast.Symbol) *ast.Symbol { + resolved := c.symbolOfCheckedExpression(location) + if resolved == nil && symbol.CheckFlags()&ast.CheckFlagsIndexSymbol != 0 && ast.IsPropertyAccessExpression(location) && !ast.IsPrivateIdentifier(location.Name()) { + resolved = c.getApplicableIndexSymbol(c.checkExpressionCached(location.Expression()), c.getLiteralTypeFromPropertyName(location.Name())) + } + return resolved +} + func (c *Checker) getTypeOfSymbol(symbol *ast.Symbol) *Type { + links := c.valueSymbolLinks.Get(symbol) + if t := links.resolvedType.cached(c); t != nil { + return t + } + links.resolvedType.begin(c) + result := c.getTypeOfSymbolUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getTypeOfSymbolUncached(symbol *ast.Symbol) *Type { if symbol.CheckFlags()&ast.CheckFlagsDeferredType != 0 { return c.getTypeOfSymbolWithDeferredType(symbol) } @@ -17023,25 +18115,67 @@ func (c *Checker) getNonMissingTypeOfSymbol(symbol *ast.Symbol) *Type { func (c *Checker) getTypeOfInstantiatedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - links.resolvedType = c.instantiateType(c.getTypeOfSymbol(links.target), links.mapper) + if links.resolvedType.cached(c) == nil { + var t *Type + if from := c.instantiatedFromUnaffected(links); from != nil { + t = c.getTypeOfSymbol(from) + } else { + t = c.instantiateType(c.getTypeOfSymbol(links.target), links.mapper) + } + links.resolvedType.set(c, t) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getWriteTypeOfInstantiatedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { - links.setWriteType(c, c.instantiateType(c.getWriteTypeOfSymbol(links.target), links.mapper)) + if links.cachedWriteType(c) == nil { + var t *Type + if from := c.instantiatedFromUnaffected(links); from != nil { + t = c.getWriteTypeOfSymbol(from) + } else { + t = c.instantiateType(c.getWriteTypeOfSymbol(links.target), links.mapper) + } + links.setWriteType(c, t) } - return links.getWriteType() + return links.cachedWriteType(c) +} + +// instantiatedFromUnaffected returns the instantiated symbol that the +// symbol of links instantiates, if its types have no type variables for +// the further instantiation to affect. The symbol then has the same types. +// Instantiating its target with the combined mappers instead can give a +// different type, as when an instantiation turns E['V'][K] into unknown +// for E := {}, but the combined one turns it into never for K := never. +func (c *Checker) instantiatedFromUnaffected(links *ValueSymbolLinks) *ast.Symbol { + from := links.getInstantiatedFrom() + if from == nil || c.couldContainTypeVariables(c.getTypeOfSymbol(from)) { + return nil + } + if from.Flags()&ast.SymbolFlagsSetAccessor != 0 && c.couldContainTypeVariables(c.getWriteTypeOfSymbol(from)) { + return nil + } + return from } func (c *Checker) getTypeOfVariableOrParameterOrProperty(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - t := c.getTypeOfVariableOrParameterOrPropertyWorker(symbol) - if t == nil { + if links.resolvedType.cached(c) == nil { + if fn := c.getContextSensitiveFunctionOfParameter(symbol); fn != nil { + // The type of a parameter of a context-sensitive function is the + // one its contextual parameter types assign it, as for the + // signature of the function (see getTypeOfFuncClassEnumModule). + if c.resolvingIndex(memoKeyOf(fn, memoContextualParameters)) == 0 { + c.assignContextualParameterTypesOfFunction(fn, CheckModeNormal) + } else { + c.assignContextualParameterTypeInProgress(fn, symbol) + } + if assigned := links.resolvedType.cached(c); assigned != nil { + return assigned + } + } + t := c.getTypeOfVariableOrParameterOrPropertyWorker(symbol) + if t == nil { panic("Unexpected nil type") } // For a contextually typed parameter it is possible that a type has already @@ -17049,26 +18183,36 @@ func (c *Checker) getTypeOfVariableOrParameterOrProperty(symbol *ast.Symbol) *Ty // to preserve this type. In fact, we need to _prefer_ that type, but it won't // be assigned until contextual typing is complete, so we need to defer in // cases where contextual typing may take place. - if links.resolvedType == nil && !c.isParameterOfContextSensitiveSignature(symbol) { - links.resolvedType = t + if assigned := links.resolvedType.cached(c); assigned != nil { + return assigned + } + if !c.isParameterOfContextSensitiveSignature(symbol) { + links.resolvedType.set(c, t) } return t } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) isParameterOfContextSensitiveSignature(symbol *ast.Symbol) bool { + return c.getContextSensitiveFunctionOfParameter(symbol) != nil +} + +// getContextSensitiveFunctionOfParameter returns the context-sensitive +// function or object literal method declaring the parameter symbol, or one +// of its binding elements, or nil. +func (c *Checker) getContextSensitiveFunctionOfParameter(symbol *ast.Symbol) *ast.Node { decl := symbol.ValueDeclaration() if decl == nil { - return false + return nil } if ast.IsBindingElement(decl) { decl = ast.WalkUpBindingElementsAndPatterns(decl) } - if ast.IsParameterDeclaration(decl) { - return c.isContextSensitiveFunctionOrObjectLiteralMethod(decl.Parent) + if ast.IsParameterDeclaration(decl) && c.isContextSensitiveFunctionOrObjectLiteralMethod(decl.Parent) { + return decl.Parent } - return false + return nil } func (c *Checker) getTypeOfVariableOrParameterOrPropertyWorker(symbol *ast.Symbol) *Type { @@ -17089,17 +18233,35 @@ func (c *Checker) getTypeOfVariableOrParameterOrPropertyWorker(symbol *ast.Symbo } return c.getWidenedType(c.getWidenedLiteralType(c.checkExpression(statements[0].Expression()))) } + if ast.IsBindingElement(declaration) && c.strictNullChecks { + // The type of a binding element depends on the type of the + // initializer its pattern destructures (see + // getBindingElementTypeFromParentType), which may in turn depend on + // the element. Resolving the initializer first, as for any element of + // the pattern, makes the cycle resolve the same way whichever element + // is requested first. + if initializer := declaration.Parent.Parent.Initializer(); initializer != nil && !c.isResolutionInProgress(initializer, TypeSystemPropertyNamePatternInitializer) { + c.beginTypeResolution(initializer, TypeSystemPropertyNamePatternInitializer, nil) + c.getTypeOfInitializer(initializer) + c.popTypeResolution() + } + } // Handle variable, parameter or property - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &c.valueSymbolLinks.Get(symbol).resolvedType.memoHeader) { return c.reportCircularityError(symbol) } + var result *Type if symbol.Flags()&ast.SymbolFlagsModuleExports != 0 { if symbol.Name() == "exports" { - return c.getTypeOfSymbol(c.resolveExternalModuleSymbol(symbol.ValueDeclaration().Symbol(), false /*dontResolveAlias*/)) + result = c.getTypeOfSymbol(c.resolveExternalModuleSymbol(symbol.ValueDeclaration().Symbol(), false /*dontResolveAlias*/)) + } else { + result = c.newAnonymousType(symbol, symbol.Members(), nil, nil, nil) } - return c.newAnonymousType(symbol, symbol.Members(), nil, nil, nil) + if !c.popTypeResolution() { + return c.reportCircularityError(symbol) + } + return result } - var result *Type switch declaration.Kind { case ast.KindParameter, ast.KindPropertyDeclaration, ast.KindPropertySignature, ast.KindVariableDeclaration, ast.KindBindingElement: @@ -17335,13 +18497,23 @@ func (c *Checker) padObjectLiteralType(t *Type, pattern *ast.Node) *Type { members.Set(prop.Name(), prop) } for _, e := range missingElements { - symbol := c.newSymbol(ast.SymbolFlagsProperty|ast.SymbolFlagsOptional, c.getPropertyNameFromBindingElement(e)) - c.valueSymbolLinks.Get(symbol).resolvedType = c.getTypeFromBindingElement(e, false /*includePatternInType*/, true /*reportErrors*/) + name := c.getPropertyNameFromBindingElement(e) + propType := c.getTypeFromBindingElement(e, false /*includePatternInType*/, true /*reportErrors*/) + key := symbolWithTypeKey{name: name, t: propType} + symbol, _ := c.paddedProperties.get(key) + if symbol == nil { + symbol = c.newSymbol(ast.SymbolFlagsProperty|ast.SymbolFlagsOptional, name) + c.valueSymbolLinks.Get(symbol).resolvedType.setIdentity(c, propType) + c.paddedProperties.intern(key, symbol) + } members.Set(symbol.Name(), symbol) } - result := c.newAnonymousType(t.symbol, members, nil, nil, c.getIndexInfosOfType(t)) - result.objectFlags = t.objectFlags - return result + indexInfos := c.getIndexInfosOfType(t) + return c.internObjectType(t.symbol, t.objectFlags, members, indexInfos, func() *Type { + result := c.newAnonymousType(t.symbol, members, nil, nil, indexInfos) + result.objectFlags = t.objectFlags + return result + }) } func (c *Checker) getPropertyNameFromBindingElement(e *ast.Node) string { @@ -17400,10 +18572,16 @@ func (c *Checker) getWidenedLiteralTypeForInitializer(declaration *ast.Node, t * func (c *Checker) getTypeOfFuncClassEnumModule(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - links.resolvedType = c.getTypeOfFuncClassEnumModuleWorker(symbol) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getTypeOfFuncClassEnumModuleWorker(symbol)) + } + if declaration := symbol.ValueDeclaration(); declaration != nil && c.isContextSensitiveFunctionOrObjectLiteralMethod(declaration) { + // Complete the signature before anything resolves the members of the + // type: doing so may check the enclosing call, which needs the + // members of the type. + c.assignContextualParameterTypesOfFunction(declaration, CheckModeNormal) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeOfFuncClassEnumModuleWorker(symbol *ast.Symbol) *Type { @@ -17452,16 +18630,23 @@ func (c *Checker) getBaseTypeVariableOfClass(symbol *ast.Symbol) *Type { * * an object type with at least one construct signature. */ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type { + t.AsInterfaceType().resolvedBaseConstructorType.begin(c) + result := c.getBaseConstructorTypeOfClassUncached(t) + c.endMemo() + return result +} + +func (c *Checker) getBaseConstructorTypeOfClassUncached(t *Type) *Type { data := t.AsInterfaceType() - if data.resolvedBaseConstructorType != nil { - return data.resolvedBaseConstructorType + if data.resolvedBaseConstructorType.cached(c) != nil { + return data.resolvedBaseConstructorType.cached(c) } baseTypeNode := getBaseTypeNodeOfClass(t) if baseTypeNode == nil { - data.resolvedBaseConstructorType = c.undefinedType - return data.resolvedBaseConstructorType + data.resolvedBaseConstructorType.set(c, c.undefinedType) + return data.resolvedBaseConstructorType.cached(c) } - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstructorType) { + if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstructorType, &data.resolvedBaseConstructorType.memoHeader) { return c.errorType } baseConstructorType := c.checkExpression(baseTypeNode.Expression()) @@ -17472,10 +18657,10 @@ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type { } if !c.popTypeResolution() { c.error(t.symbol.ValueDeclaration(), diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_base_expression, c.symbolToString(t.symbol)) - if data.resolvedBaseConstructorType == nil { - data.resolvedBaseConstructorType = c.errorType + if data.resolvedBaseConstructorType.cached(c) == nil { + data.resolvedBaseConstructorType.set(c, c.errorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.cached(c) } if baseConstructorType.flags&TypeFlagsAny == 0 && baseConstructorType != c.nullWideningType && !c.isConstructorType(baseConstructorType) { err := c.error(baseTypeNode.Expression(), diagnostics.Type_0_is_not_a_constructor_function_type, c.TypeToString(baseConstructorType)) @@ -17492,15 +18677,15 @@ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type { err.AddRelatedInfo(createDiagnosticForNode(baseConstructorType.symbol.Declarations()[0], diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, c.symbolToString(baseConstructorType.symbol), c.TypeToString(ctorReturn))) } } - if data.resolvedBaseConstructorType == nil { - data.resolvedBaseConstructorType = c.errorType + if data.resolvedBaseConstructorType.cached(c) == nil { + data.resolvedBaseConstructorType.set(c, c.errorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.cached(c) } - if data.resolvedBaseConstructorType == nil { - data.resolvedBaseConstructorType = baseConstructorType + if data.resolvedBaseConstructorType.cached(c) == nil { + data.resolvedBaseConstructorType.set(c, baseConstructorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.cached(c) } func (c *Checker) isFunctionType(t *Type) bool { @@ -17554,6 +18739,17 @@ func (c *Checker) getConstraintOfType(t *Type) *Type { } func (c *Checker) getConstraintOfTypeParameter(typeParameter *Type) *Type { + key := memoKeyOf(typeParameter, memoTypeParameterConstraint) + if typeParameter.flags&TypeFlagsTypeParameter != 0 && typeParameter.AsTypeParameter().resolvedBaseConstraint.peek() != nil && typeParameter.AsTypeParameter().constraint.peek() != nil && c.readsWithoutMemo(key) { + return c.getConstraintOfTypeParameterUncached(typeParameter) + } + c.beginMemo(key) + result := c.getConstraintOfTypeParameterUncached(typeParameter) + c.endMemo() + return result +} + +func (c *Checker) getConstraintOfTypeParameterUncached(typeParameter *Type) *Type { if c.hasNonCircularBaseConstraint(typeParameter) { return c.getConstraintFromTypeParameter(typeParameter) } @@ -17571,7 +18767,7 @@ func (c *Checker) getConstraintFromTypeParameter(t *Type) *Type { } tp := t.AsTypeParameter() - if tp.constraint == nil { + if tp.constraint.cached(c) == nil { var constraint *Type if tp.target != nil { constraint = c.instantiateType(c.getConstraintOfTypeParameter(tp.target), tp.mapper) @@ -17595,10 +18791,10 @@ func (c *Checker) getConstraintFromTypeParameter(t *Type) *Type { if constraint == nil { constraint = c.noConstraintType } - tp.constraint = constraint + tp.constraint.set(c, constraint) } - if tp.constraint != c.noConstraintType { - return tp.constraint + if tp.constraint.cached(c) != c.noConstraintType { + return tp.constraint.cached(c) } return nil } @@ -17625,7 +18821,7 @@ func (c *Checker) getInferredTypeParameterConstraint(t *Type, omitTypeReferences } switch { case ast.IsTypeReferenceNode(parent) && !omitTypeReferences: - typeParameters := c.getTypeParametersForTypeReferenceOrImport(parent) + typeParameters := c.getDeclaredTypeParametersOfTypeReference(parent) if typeParameters != nil { index := slices.Index(parent.TypeArguments(), child) if index >= 0 && index < len(typeParameters) { @@ -17684,7 +18880,7 @@ func (c *Checker) getInferredTypeParameterConstraint(t *Type, omitTypeReferences func (c *Checker) getTypeParametersForTypeReferenceOrImport(node *ast.Node) []*Type { t := c.getTypeFromTypeNode(node) if !c.isErrorType(t) { - symbol := c.getResolvedSymbolOrNil(node) + symbol := c.getSymbolOfTypeNode(node) if symbol != nil { return c.getTypeParametersForTypeAndSymbol(t, symbol) } @@ -17692,10 +18888,36 @@ func (c *Checker) getTypeParametersForTypeReferenceOrImport(node *ast.Node) []*T return nil } +// getDeclaredTypeParametersOfTypeReference returns the type parameters of the +// type a type reference refers to, if it has an acceptable number of type +// arguments. Unlike getTypeParametersForTypeReferenceOrImport, it does not +// instantiate the type, which can need the constraints of the infer type +// parameters among its type arguments, inferred from these type parameters. +func (c *Checker) getDeclaredTypeParametersOfTypeReference(node *ast.Node) []*Type { + symbol := c.getSymbolFromTypeReference(node) + if symbol == c.unknownSymbol { + return nil + } + declared := c.getDeclaredTypeOfSymbol(symbol) + if c.isErrorType(declared) { + return nil + } + var typeParameters []*Type + if symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 { + typeParameters = c.typeAliasLinks.Get(symbol).typeParameters + } else if declared.objectFlags&ObjectFlagsClassOrInterface != 0 { + typeParameters = declared.AsInterfaceType().LocalTypeParameters() + } + if n := len(node.TypeArguments()); n < c.getMinTypeArgumentCount(typeParameters) || n > len(typeParameters) { + return nil + } + return typeParameters +} + func (c *Checker) getTypeParametersForTypeAndSymbol(t *Type, symbol *ast.Symbol) []*Type { if !c.isErrorType(t) { if symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 { - if typeParameters := c.typeAliasLinks.Get(symbol).typeParameters; len(typeParameters) != 0 { + if typeParameters := c.getTypeParametersOfTypeAlias(symbol); len(typeParameters) != 0 { return typeParameters } } @@ -17743,10 +18965,11 @@ func (c *Checker) getConstraintFromIndexedAccess(t *Type) *Type { } func (c *Checker) getConstraintOfConditionalType(t *Type) *Type { - if c.hasNonCircularBaseConstraint(t) { - return c.getConstraintFromConditionalType(t) - } - return nil + // The constraint of a conditional type is computed from its branches one + // level at a time, so it is well defined even where following constraints + // from it leads back to it, which makes its base constraint circular. + // Callers following constraints further stop where they nest too deeply. + return c.getConstraintFromConditionalType(t) } func (c *Checker) getConstraintFromConditionalType(t *Type) *Type { @@ -17759,7 +18982,7 @@ func (c *Checker) getConstraintFromConditionalType(t *Type) *Type { func (c *Checker) getDefaultConstraintOfConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedDefaultConstraint == nil { + return c.memoCompute(&d.resolvedDefaultConstraint, func() *Type { // An `any` branch of a conditional type would normally be viral - specifically, without special handling here, // a conditional type with a single branch of type `any` would be assignable to anything, since it's constraint would simplify to // just `any`. This result is _usually_ unwanted - so instead here we elide an `any` branch from the constraint type, @@ -17768,19 +18991,18 @@ func (c *Checker) getDefaultConstraintOfConditionalType(t *Type) *Type { falseConstraint := c.getFalseTypeFromConditionalType(t) switch { case IsTypeAny(trueConstraint): - d.resolvedDefaultConstraint = falseConstraint + return falseConstraint case IsTypeAny(falseConstraint): - d.resolvedDefaultConstraint = trueConstraint + return trueConstraint default: - d.resolvedDefaultConstraint = c.getUnionType([]*Type{trueConstraint, falseConstraint}) + return c.getUnionType([]*Type{trueConstraint, falseConstraint}) } - } - return d.resolvedDefaultConstraint + }) } func (c *Checker) getConstraintOfDistributiveConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedConstraintOfDistributive == nil { + result := c.memoCompute(&d.resolvedConstraintOfDistributive, func() *Type { // Check if we have a conditional type of the form 'T extends U ? X : Y', where T is a constrained // type parameter. If so, create an instantiation of the conditional type where T is replaced // with its constraint. We do this because if the constraint is a union type it will be distributed @@ -17792,33 +19014,39 @@ func (c *Checker) getConstraintOfDistributiveConditionalType(t *Type) *Type { // Please note: the distributive constraint is a kludge for emulating what a negated type could to do filter // a union - once negated types exist and are applied to the conditional false branch, this "constraint" // likely doesn't need to exist. - if d.root.isDistributive && c.cachedTypes[CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: t.id}] != t { + if d.root.isDistributive && !d.restrictive { constraint := c.getSimplifiedType(d.checkType, false /*writing*/) if constraint == d.checkType { - constraint = c.getConstraintOfType(constraint) + // A conditional check type whose base constraint is circular + // has a constraint, but distributing over it leads back into + // the circularity, leaving this type without a usable one. + if constraint.flags&TypeFlagsConditional != 0 && !c.hasNonCircularBaseConstraint(constraint) { + constraint = nil + } else { + constraint = c.getConstraintOfType(constraint) + } } if constraint != nil && constraint != d.checkType { instantiated := c.getConditionalTypeInstantiation(t, prependTypeMapping(d.root.checkType, constraint, d.mapper), true /*forConstraint*/, nil) if instantiated.flags&TypeFlagsNever == 0 { - d.resolvedConstraintOfDistributive = instantiated return instantiated } } } - d.resolvedConstraintOfDistributive = c.noConstraintType - } - if d.resolvedConstraintOfDistributive != c.noConstraintType { - return d.resolvedConstraintOfDistributive + return c.noConstraintType + }) + if result != c.noConstraintType { + return result } return nil } func (c *Checker) getDeclaredTypeOfClassOrInterface(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if links.declaredType == nil { + if links.declaredType.cached(c) == nil { kind := core.IfElse(symbol.Flags()&ast.SymbolFlagsClass != 0, ObjectFlagsClass, ObjectFlagsInterface) t := c.newObjectType(kind, symbol) - links.declaredType = t + links.declaredType.setIdentity(c, t) outerTypeParameters := c.getOuterTypeParametersOfClassOrInterface(symbol) typeParameters := c.appendLocalTypeParametersOfClassOrInterfaceOrTypeAlias(outerTypeParameters, symbol) // A class or interface is generic if it has type parameters or a "this" type. We always give classes a "this" type @@ -17831,16 +19059,15 @@ func (c *Checker) getDeclaredTypeOfClassOrInterface(symbol *ast.Symbol) *Type { d := t.AsInterfaceType() d.thisType = c.newTypeParameter(symbol) d.thisType.AsTypeParameter().isThisType = true - d.thisType.AsTypeParameter().constraint = t + d.thisType.AsTypeParameter().constraint.intern(t) d.allTypeParameters = append(typeParameters, d.thisType) d.outerTypeParameterCount = len(outerTypeParameters) - d.resolvedTypeArguments = d.TypeParameters() - d.instantiations = make(map[CacheHashKey]*Type) - d.instantiations[getTypeListKey(d.resolvedTypeArguments)] = t + d.resolvedTypeArguments.intern(d.TypeParameters()) + d.instantiations.intern(getTypeListKey(d.TypeParameters()), t) d.target = t } } - return links.declaredType + return links.declaredType.cached(c) } /** @@ -17968,15 +19195,15 @@ func (b *keyBuilder) writeAlias(alias *TypeAlias) { } } -func (b *keyBuilder) writeGenericTypeReferences(source *Type, target *Type, ignoreConstraints bool) bool { +func (b *keyBuilder) writeGenericTypeReferences(c *Checker, source *Type, target *Type, ignoreConstraints bool) bool { var constrained bool typeParameters := make([]*Type, 0, 8) var writeTypeReference func(*Type, int) writeTypeReference = func(ref *Type, depth int) { b.writeType(ref.Target()) - for _, t := range ref.AsTypeReference().resolvedTypeArguments { + for _, t := range c.getTypeArguments(ref) { if t.flags&TypeFlagsTypeParameter != 0 { - if ignoreConstraints || t.checker.getConstraintOfTypeParameter(t) == nil { + if ignoreConstraints || c.getConstraintOfTypeParameter(t) == nil { index := slices.Index(typeParameters, t) if index < 0 { index = len(typeParameters) @@ -17987,7 +19214,7 @@ func (b *keyBuilder) writeGenericTypeReferences(source *Type, target *Type, igno continue } constrained = true - } else if depth < 4 && isTypeReferenceWithGenericArguments(t) { + } else if depth < 4 && c.isTypeReferenceWithGenericArguments(t) { b.writeByte('<') writeTypeReference(t, depth+1) b.writeByte('>') @@ -18013,6 +19240,51 @@ func (b *keyBuilder) writeNode(node *ast.Node) { } } +// An objectLiteralType is a type created for an object literal, with the +// content it was created from; see isSameObjectLiteralType. +type objectLiteralType struct { + flags ObjectFlags + properties ast.SymbolTable + indexInfos []*IndexInfo + t *Type +} + +// isSameObjectLiteralType reports whether an object literal type created +// before has the given content, so that checking the same object literal +// again with the same results yields the same type. +func (c *Checker) isSameObjectLiteralType(e objectLiteralType, flags ObjectFlags, properties ast.SymbolTable, indexInfos []*IndexInfo) bool { + if e.flags != flags || e.properties.Len() != properties.Len() || len(e.indexInfos) != len(indexInfos) { + return false + } + for i, info := range indexInfos { + other := e.indexInfos[i] + if info.keyType != other.keyType || info.valueType != other.valueType || info.isReadonly != other.isReadonly || !slices.Equal(info.components, other.components) { + return false + } + } + for i := range properties.Len() { + name, prop := properties.At(i) + otherName, other := e.properties.At(i) + if name != otherName || prop.Flags() != other.Flags() || prop.CheckFlags() != other.CheckFlags() { + return false + } + // Members created by an object literal have their types set at + // creation; other members (accessors) are the declared symbols. + links := c.valueSymbolLinks.TryGet(prop) + otherLinks := c.valueSymbolLinks.TryGet(other) + if links == nil || links.target == nil || otherLinks == nil || otherLinks.target == nil { + if prop != other { + return false + } + continue + } + if links.getNameType() != otherLinks.getNameType() || links.typeOfCreation() != otherLinks.typeOfCreation() { + return false + } + } + return true +} + func getTypeListKey(types []*Type) CacheHashKey { var b keyBuilder b.writeTypes(types) @@ -18130,15 +19402,22 @@ func getConditionalTypeKey(typeArguments []*Type, alias *TypeAlias, forConstrain return b.hash() } -func getRelationKey(source *Type, target *Type, intersectionState IntersectionState, isIdentity bool, ignoreConstraints bool) (CacheHashKey, bool) { +func (c *Checker) getRelationKey(source *Type, target *Type, intersectionState IntersectionState, isIdentity bool, ignoreConstraints bool) (CacheHashKey, bool) { if isIdentity && source.id > target.id { source, target = target, source } var b keyBuilder var constrained bool - if isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) { - b.writeByte('g') - constrained = b.writeGenericTypeReferences(source, target, ignoreConstraints) + if c.isTypeReferenceWithGenericArguments(source) && c.isTypeReferenceWithGenericArguments(target) { + // Marker types are compared structurally while their variances are being + // measured, and other instantiations with the same key by those variances, + // which may be guesses until the measurement finishes. + if c.isMarkerType(source) || c.isMarkerType(target) { + b.writeByte('m') + } else { + b.writeByte('g') + } + constrained = b.writeGenericTypeReferences(c, source, target, ignoreConstraints) } else { b.writeByte('s') b.writeType(source) @@ -18157,9 +19436,9 @@ func getNodeListKey(nodes []*ast.Node) CacheHashKey { return b.hash() } -func isTypeReferenceWithGenericArguments(t *Type) bool { - return isNonDeferredTypeReference(t) && core.Some(t.checker.getTypeArguments(t), func(t *Type) bool { - return t.flags&TypeFlagsTypeParameter != 0 || isTypeReferenceWithGenericArguments(t) +func (c *Checker) isTypeReferenceWithGenericArguments(t *Type) bool { + return isNonDeferredTypeReference(t) && core.Some(c.getTypeArguments(t), func(t *Type) bool { + return t.flags&TypeFlagsTypeParameter != 0 || c.isTypeReferenceWithGenericArguments(t) }) } @@ -18216,8 +19495,8 @@ func (c *Checker) getTypeForBindingElementParent(node *ast.Node, checkMode Check if checkMode == CheckModeNormal { // We can use a cached resolved type if no optionality was included in that type. if symbol := c.getSymbolOfDeclaration(node); symbol != nil { - if resolvedType := c.valueSymbolLinks.Get(symbol).resolvedType; resolvedType != nil && !(c.strictNullChecks && isOptionalDeclaration(node)) { - return resolvedType + if !(c.strictNullChecks && isOptionalDeclaration(node)) && node.Kind == ast.KindParameter && c.isContextSensitiveFunctionOrObjectLiteralMethod(node.Parent) { + return c.getTypeOfSymbol(symbol) } } } @@ -18350,9 +19629,12 @@ func (c *Checker) getRestType(source *Type, properties []*ast.Node, symbol *ast. for _, prop := range spreadableProperties { members.Set(prop.Name(), c.getSpreadSymbol(prop, false /*readonly*/)) } - result := c.newAnonymousType(symbol, members, nil, nil, c.getIndexInfosOfType(source)) - result.objectFlags |= ObjectFlagsObjectRestType - return result + indexInfos := c.getIndexInfosOfType(source) + return c.internObjectType(symbol, ObjectFlagsAnonymous|ObjectFlagsObjectRestType, members, indexInfos, func() *Type { + result := c.newAnonymousType(symbol, members, nil, nil, indexInfos) + result.objectFlags |= ObjectFlagsObjectRestType + return result + }) } // Determine the control flow type associated with a destructuring declaration or assignment. The following @@ -18423,7 +19705,10 @@ func (c *Checker) getParentElementAccess(node *ast.Node) *ast.Node { // the parameter. func (c *Checker) getTypeFromBindingPattern(pattern *ast.Node, includePatternInType bool, reportErrors bool) *Type { if includePatternInType { - c.contextualBindingPatterns = append(c.contextualBindingPatterns, pattern) + // While the implied type is computed, references to the pattern's own + // elements are any (see checkIdentifier), so nothing computed from + // them may be cached; see isResolvingAnywhere. + c.beginTypeResolution(pattern, TypeSystemPropertyNameContextualBindingPattern, nil) } var result *Type if ast.IsObjectBindingPattern(pattern) { @@ -18432,7 +19717,7 @@ func (c *Checker) getTypeFromBindingPattern(pattern *ast.Node, includePatternInT result = c.getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors) } if includePatternInType { - c.contextualBindingPatterns = c.contextualBindingPatterns[:len(c.contextualBindingPatterns)-1] + c.popTypeResolution() } return result } @@ -18457,19 +19742,41 @@ func (c *Checker) getTypeFromObjectBindingPattern(pattern *ast.Node, includePatt text := getPropertyNameFromType(exprType) flags := ast.SymbolFlagsProperty | core.IfElse(e.Initializer() != nil, ast.SymbolFlagsOptional, 0) symbol := c.newSymbol(flags, text) - c.valueSymbolLinks.Get(symbol).resolvedType = c.getTypeFromBindingElement(e, includePatternInType, reportErrors) + c.valueSymbolLinks.Get(symbol).resolvedType.setIdentity(c, c.getTypeFromBindingElement(e, includePatternInType, reportErrors)) members.Set(symbol.Name(), symbol) } var indexInfos []*IndexInfo if stringIndexInfo != nil { indexInfos = []*IndexInfo{stringIndexInfo} } + // The members are declared by the pattern's elements, so patterns + // implying the same members still need distinct types. + var b keyBuilder + b.writeNode(pattern) + if includePatternInType { + b.writeByte(1) + } else { + b.writeByte(0) + } + b.writeUint32(uint32(objectFlags)) + b.writeInt(len(indexInfos)) + for name, member := range members.All() { + b.writeString(name) + b.writeByte(0) + b.writeUint32(uint32(member.Flags())) + b.writeType(c.valueSymbolLinks.Get(member).typeOfCreation()) + } + key := b.hash() + if existing, _ := c.bindingPatternTypes.get(key); existing != nil { + return existing + } result := c.newAnonymousType(nil, members, nil, nil, indexInfos) result.objectFlags |= objectFlags if includePatternInType { - c.patternForType[result] = pattern + c.patternForType.intern(result, pattern) result.objectFlags |= ObjectFlagsContainsObjectOrArrayLiteral } + c.bindingPatternTypes.intern(key, result) return result } @@ -18513,9 +19820,17 @@ func (c *Checker) getTypeFromArrayBindingPattern(pattern *ast.Node, includePatte } result := c.createTupleTypeEx(elementTypes, elementInfos, false) if includePatternInType { + var b keyBuilder + b.writeNode(pattern) + b.writeType(result) + key := b.hash() + if existing, _ := c.bindingPatternTypes.get(key); existing != nil { + return existing + } result = c.cloneTypeReference(result) - c.patternForType[result] = pattern + c.patternForType.intern(result, pattern) result.objectFlags |= ObjectFlagsContainsObjectOrArrayLiteral + c.bindingPatternTypes.intern(key, result) } return result } @@ -18708,16 +20023,17 @@ func (c *Checker) getTypeFromPropertyDescriptor(node *ast.Node) *Type { // A property is considered a constructor declared property when all declaration sites are this.xxx assignments, // when no declaration sites have JSDoc type annotations, and when at least one declaration site is in the body of // a class constructor. +type thisExpando struct { + kind thisAssignmentDeclarationKind + location *ast.Node +} + func (c *Checker) isConstructorDeclaredThisProperty(symbol *ast.Symbol) (thisAssignmentDeclarationKind, *ast.Node) { if symbol.ValueDeclaration() == nil || !ast.IsBinaryExpression(symbol.ValueDeclaration()) { return thisAssignmentDeclarationNone, nil } - if kind, ok := c.thisExpandoKinds[symbol]; ok { - location, ok2 := c.thisExpandoLocations[symbol] - if !ok2 { - panic("location should be cached whenever this expando symbol is cached") - } - return kind, location + if cached, ok := c.thisExpandos.get(symbol); ok { + return cached.kind, cached.location } allThis := true var typeAnnotation *ast.Node @@ -18748,8 +20064,7 @@ func (c *Checker) isConstructorDeclaredThisProperty(symbol *ast.Symbol) (thisAss kind = core.IfElse(location == nil, thisAssignmentDeclarationMethod, thisAssignmentDeclarationConstructor) } } - c.thisExpandoKinds[symbol] = kind - c.thisExpandoLocations[symbol] = location + c.thisExpandos.intern(symbol, thisExpando{kind, location}) return kind, location } @@ -18883,9 +20198,12 @@ func (c *Checker) getWidenedType(t *Type) *Type { func (c *Checker) getWidenedTypeWithContext(t *Type, context *WideningContext) *Type { if t.objectFlags&ObjectFlagsRequiresWidening != 0 { if context == nil { - if cached := c.cachedTypes[CachedTypeKey{kind: CachedTypeKindWidened, typeId: t.id}]; cached != nil { + key := CachedTypeKey{kind: CachedTypeKindWidened, typeId: t.id} + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) + defer c.endMemo() } var result *Type switch { @@ -18914,7 +20232,7 @@ func (c *Checker) getWidenedTypeWithContext(t *Type, context *WideningContext) * result = c.createTypeReference(t.Target(), core.SameMap(c.getTypeArguments(t), c.getWidenedType)) } if result != nil && context == nil { - c.cachedTypes[CachedTypeKey{kind: CachedTypeKindWidened, typeId: t.id}] = result + c.cachedTypes.set(c, CachedTypeKey{kind: CachedTypeKindWidened, typeId: t.id}, result) } return core.OrElse(result, t) } @@ -18938,11 +20256,16 @@ func (c *Checker) getWidenedTypeOfObjectLiteral(t *Type, context *WideningContex } } } - result := c.newAnonymousType(t.symbol, members, nil, nil, core.SameMap(c.getIndexInfosOfType(t), func(info *IndexInfo) *IndexInfo { + indexInfos := core.SameMap(c.getIndexInfosOfType(t), func(info *IndexInfo) *IndexInfo { return c.newIndexInfo(info.keyType, c.getWidenedType(info.valueType), info.isReadonly, info.declaration, info.components) - })) + }) // Retain js literal flag through widening - result.objectFlags |= t.objectFlags & (ObjectFlagsJSLiteral | ObjectFlagsNonInferrableType) + flags := t.objectFlags & (ObjectFlagsJSLiteral | ObjectFlagsNonInferrableType) + result := c.internObjectType(t.symbol, ObjectFlagsAnonymous|flags, members, indexInfos, func() *Type { + result := c.newAnonymousType(t.symbol, members, nil, nil, indexInfos) + result.objectFlags |= flags + return result + }) // Only cache in child contexts since the root context never widens a particular object literal type more than once if context != nil && context.parent != nil { if context.widenedTypes == nil { @@ -18968,7 +20291,7 @@ func (c *Checker) getWidenedProperty(prop *ast.Symbol, context *WideningContext) if widened == original { return prop } - return c.createSymbolWithType(prop, widened) + return c.getSymbolWithType(prop, widened) } func (w *WideningContext) getChildContext(propertyName string) *WideningContext { @@ -19015,27 +20338,36 @@ func (c *Checker) getSiblingsOfContext(context *WideningContext) []*Type { } func (c *Checker) getUndefinedProperty(prop *ast.Symbol) *ast.Symbol { - if cached := c.undefinedProperties[prop]; cached != nil { + if cached, _ := c.undefinedProperties.cached(c, prop); cached != nil { return cached } + c.undefinedProperties.begin(c, prop) result := c.createSymbolWithType(prop, c.undefinedOrMissingType) result.SetFlags(result.Flags() | ast.SymbolFlagsOptional) - c.undefinedProperties[prop] = result + c.undefinedProperties.set(c, prop, result) + c.endMemo() return result } func (c *Checker) getTypeOfEnumMember(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - links.resolvedType = c.getDeclaredTypeOfEnumMember(symbol) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getDeclaredTypeOfEnumMember(symbol)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeOfAccessors(symbol *ast.Symbol) *Type { + c.beginMemo(memoKeyOf(symbol, memoAccessorType)) + result := c.getTypeOfAccessorsUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getTypeOfAccessorsUncached(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { + if links.resolvedType.cached(c) == nil { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &links.resolvedType.memoHeader) { return c.errorType } getter := ast.GetDeclarationOfKind(symbol, ast.KindGetAccessor) @@ -19080,17 +20412,20 @@ func (c *Checker) getTypeOfAccessors(symbol *ast.Symbol) *Type { } t = c.anyType } - if links.resolvedType == nil { - links.resolvedType = t + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, t) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameWriteType) { + if links.cachedWriteType(c) == nil { + if links.extra == nil { + links.extra = c.valueSymbolExtraArena.New() + } + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameWriteType, &links.extra.writeType.memoHeader) { return c.errorType } setter := ast.GetDeclarationOfKind(symbol, ast.KindSetAccessor) @@ -19108,7 +20443,7 @@ func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { writeType = c.anyType } // Absent an explicit setter type annotation we use the read type of the accessor. - if links.getWriteType() == nil { + if links.cachedWriteType(c) == nil { if writeType != nil { links.setWriteType(c, writeType) } else { @@ -19116,13 +20451,13 @@ func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { } } } - return links.getWriteType() + return links.cachedWriteType(c) } func (c *Checker) getTypeOfAlias(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { + if links.resolvedType.cached(c) == nil { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &links.resolvedType.memoHeader) { return c.errorType } targetSymbol := c.resolveAlias(symbol) @@ -19132,22 +20467,22 @@ func (c *Checker) getTypeOfAlias(symbol *ast.Symbol) *Type { // type symbol, call getDeclaredTypeOfSymbol. // This check is important because without it, a call to getTypeOfSymbol could end // up recursively calling getTypeOfAlias, causing a stack overflow. - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { if c.getSymbolFlags(targetSymbol)&ast.SymbolFlagsValue != 0 { - links.resolvedType = c.getTypeOfSymbol(targetSymbol) + links.resolvedType.set(c, c.getTypeOfSymbol(targetSymbol)) } else { - links.resolvedType = c.errorType + links.resolvedType.set(c, c.errorType) } } if !c.popTypeResolution() { c.reportCircularityError(core.OrElse(exportSymbol, symbol)) - if links.resolvedType == nil { - links.resolvedType = c.errorType + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.errorType) } - return links.resolvedType + return links.resolvedType.cached(c) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) addOptionality(t *Type) *Type { @@ -19232,12 +20567,13 @@ func (c *Checker) getEffectivePropertyNameForPropertyNameNode(node *ast.Property case ast.IsComputedPropertyName(node): // This is cached so `getTypeOfExpression` isn't constantly reinvoked for every property name lookup links := c.computedNameLinks.Get(node) - if links != nil && !links.hasName.IsUnknown() { - return links.name, links.hasName.IsTrue() + if result := links.name.cached(c); !result.exists.IsUnknown() { + return result.name, result.exists.IsTrue() } + links.name.begin(c) name, exists := c.tryGetNameFromType(c.getTypeOfExpression(node.Expression())) - links.name = name - links.hasName = core.BoolToTristate(exists) + links.name.set(c, computedName{name: name, exists: core.BoolToTristate(exists)}) + c.endMemo() return name, exists } return "", false @@ -19278,69 +20614,658 @@ func (c *Checker) getCombinedModifierFlagsCached(node *ast.Node) ast.ModifierFla * * @param target The symbol, type, or signature whose type is being queried * @param propertyName The property name that should be used to query the target for its type + * @param memo The memo that caches the result of the resolution, or nil */ -func (c *Checker) pushTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { +func (c *Checker) pushTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName, memo *memoHeader) bool { resolutionCycleStartIndex := c.findResolutionCycleStartIndex(target, propertyName) if resolutionCycleStartIndex >= 0 { - // A cycle was found - for i := resolutionCycleStartIndex; i < len(c.typeResolutions); i++ { - c.typeResolutions[i].result = false + if !c.yieldCycleToMembers(resolutionCycleStartIndex) { + return false } + } + c.beginTypeResolution(target, propertyName, memo) + if resolutionCycleStartIndex < 0 && c.resolutionStart > 0 { + if i := c.findHiddenResolution(target, propertyName); i >= 0 { + c.resolutions[len(c.resolutions)-1].typeResolution.outerSelf = int32(i + 1) + } + } + return true +} + +// findHiddenResolution returns the index in resolutions of the outermost +// resolution of the property of target in progress below resolutionStart, +// or -1. +func (c *Checker) findHiddenResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { + found := -1 + for i := int(c.resolutions[len(c.resolutions)-1].prevTypeResolution) - 1; i >= 0; i = int(c.resolutions[i].prevTypeResolution) - 1 { + if i < c.resolutionStart { + if r := &c.resolutions[i].typeResolution; r.target == target && r.propertyName == propertyName { + found = i + } + } + } + return found +} + +// cycleYield is a canonical recomputation in progress; see yieldCycle. +type cycleYield struct { + end int // Index in resolutions of the resolution whose pop ends it, or -1 + target TypeSystemEntity + propertyName TypeSystemPropertyName + savedResolutionStart int + savedVisibleStart int + savedVisibleSigs int + savedDepths [3]depthLimit + savedReverseMapped reverseMappedState + savedContextual []ContextualInfo + savedInference []InferenceContextInfo + shadowed []shadowedResolving +} + +type reverseMappedState struct { + sourceStack []*Type + targetStack []*Type + expandingFlags ExpandingFlags + start int32 +} + +type shadowedResolving struct { + key memoKey + index int32 +} + +// yieldCycle handles re-entering the resolution in progress at start, a +// cycle that would fail the resolution re-entered. Which resolution is +// re-entered depends on which was entered first, so a cycle through members +// declared before the one re-entered (see compareCycleMembers) fails at the +// first of those instead, as if it had been resolved first: it is computed +// again from scratch, with nothing in progress visible, and the resolution +// re-entered is then computed again likewise, by the caller, which pushes it. +// The computations in progress then continue from those results. +// Termination: a resolution is never computed again while it is already +// being computed again. +func (c *Checker) yieldCycle(start int) bool { + r := c.resolutions[start].typeResolution + if c.isYieldingTo(r.target, r.propertyName) { + return false + } + first := c.firstCycleMember(start) + if first == nil { return false } - c.typeResolutions = append(c.typeResolutions, TypeResolution{target: target, propertyName: propertyName, result: true}) + c.resolveCycleMember(*first) + c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), len(c.resolutions)) return true } -/** - * Pop an entry from the type resolution stack and return its associated result value. The result value will - * be true if no circularities were detected, or false if a circularity was found. - */ -func (c *Checker) popTypeResolution() bool { - lastIndex := len(c.typeResolutions) - 1 - result := c.typeResolutions[lastIndex].result - c.typeResolutions[lastIndex] = TypeResolution{} // Clear the last entry to avoid memory leaks - c.typeResolutions = c.typeResolutions[:lastIndex] - return result +// yieldObservedCycle handles observing the resolution in progress at start +// without failing it, as yieldCycle handles re-entering it: if members of +// the cycle are declared before the resolution observed, the first of them +// is computed again from scratch, as if it had been resolved first, so that +// the caller can use its result. +func (c *Checker) yieldObservedCycle(start int) { + if r := &c.resolutions[start].typeResolution; c.isYieldingTo(r.target, r.propertyName) { + return + } + if first := c.firstCycleMember(start); first != nil { + c.resolveCycleMember(*first) + } } -func (c *Checker) findResolutionCycleStartIndex(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { - for i := len(c.typeResolutions) - 1; i >= c.resolutionStart; i-- { - resolution := &c.typeResolutions[i] - if c.typeResolutionHasProperty(resolution) { - return -1 - } - if resolution.target == target && resolution.propertyName == propertyName { - return i +// firstCycleMember returns the member of the cycle from the resolution at +// start to the top of the stack that is resolved first, if it is not the +// resolution at start, and is not already being computed again. +func (c *Checker) firstCycleMember(start int) *TypeResolution { + entered := &c.resolutions[start].typeResolution + var first *TypeResolution + if isCycleMember(entered) { + first = entered + } + for i := start + 1; i < len(c.resolutions); i++ { + if f := &c.resolutions[i]; f.isTypeResolution && isCycleMember(&f.typeResolution) && (first == nil || c.compareCycleMembers(&f.typeResolution, first) < 0) { + first = &f.typeResolution } } - return -1 + if first == nil || first == entered || c.isYieldingTo(first.target, first.propertyName) { + return nil + } + return first } -func (c *Checker) typeResolutionHasProperty(r *TypeResolution) bool { +// isCycleMember reports whether a type resolution may be resolved first in +// place of the one a cycle re-entered: the type of a symbol, or the return +// type of a declared signature. +func isCycleMember(r *TypeResolution) bool { switch r.propertyName { case TypeSystemPropertyNameType: - return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).resolvedType != nil - case TypeSystemPropertyNameDeclaredType: - return c.typeAliasLinks.Get(r.target.(*ast.Symbol)).declaredType != nil - case TypeSystemPropertyNameResolvedTypeArguments: - return r.target.(*Type).AsTypeReference().resolvedTypeArguments != nil - case TypeSystemPropertyNameResolvedBaseTypes: - return r.target.(*Type).AsInterfaceType().baseTypesResolved - case TypeSystemPropertyNameResolvedBaseConstructorType: - return r.target.(*Type).AsInterfaceType().resolvedBaseConstructorType != nil + return true case TypeSystemPropertyNameResolvedReturnType: - return r.target.(*Signature).resolvedReturnType != nil - case TypeSystemPropertyNameResolvedBaseConstraint: - return r.target.(*Type).AsConstrainedType().resolvedBaseConstraint != nil - case TypeSystemPropertyNameInitializerIsUndefined: - return c.nodeLinks.Get(r.target.(*ast.Node)).flags&NodeCheckFlagsInitializerIsUndefinedComputed != 0 - case TypeSystemPropertyNameWriteType: - return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).getWriteType() != nil - case TypeSystemPropertyNameAliasTarget: - return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget != nil + sig := r.target.(*Signature) + return sig.target == nil && sig.getComposite() == nil && sig.declaration != nil } - panic("Unhandled case in typeResolutionHasProperty") + return false +} + +// compareCycleMembers orders the members of a cycle in program order of +// their declarations, symbols first among members with the same one. +func (c *Checker) compareCycleMembers(a, b *TypeResolution) int { + aSymbol, aIsSymbol := a.target.(*ast.Symbol) + bSymbol, bIsSymbol := b.target.(*ast.Symbol) + switch { + case aIsSymbol && bIsSymbol: + return c.compareSymbols(aSymbol, bSymbol) + case aIsSymbol: + return c.compareSymbolToNode(aSymbol, b.target.(*Signature).declaration) + case bIsSymbol: + return -c.compareSymbolToNode(bSymbol, a.target.(*Signature).declaration) + } + return c.compareNodes(a.target.(*Signature).declaration, b.target.(*Signature).declaration) +} + +// compareSymbolToNode orders a symbol by its first declaration against node, +// the symbol first if that is node. +func (c *Checker) compareSymbolToNode(s *ast.Symbol, node *ast.Node) int { + if len(s.Declarations()) == 0 { + return 1 + } + if r := c.compareNodes(s.Declarations()[0], node); r != 0 { + return r + } + return -1 +} + +// resolveCycleMember computes the result of a member of a cycle again from +// scratch, with nothing in progress visible. +func (c *Checker) resolveCycleMember(r TypeResolution) { + target, propertyName := r.target, r.propertyName + c.beginCycleYield(target, propertyName, -1, len(c.resolutions)) + switch propertyName { + case TypeSystemPropertyNameType: + c.getTypeOfSymbol(target.(*ast.Symbol)) + case TypeSystemPropertyNameResolvedReturnType: + c.getReturnTypeOfSignature(target.(*Signature)) + } + c.endCycleYield() +} + +// yieldCycleToMembers handles re-entering the type resolution in progress +// at start, a cycle that would fail it, when the cycle passes through a +// member table. Entering the cycle at the member table instead would not +// fail, as the table is available while it is resolved, so the resolution +// re-entered is computed again as if the table had been entered first: by +// the caller, with everything entered before the table hidden. A module +// table is instead resolved again itself, as if entered first (see +// resolveModuleTableMembers), so everything above it fails until then, to +// be discarded. Otherwise it yields as yieldCycle does. It reports whether +// the resolution re-entered may be pushed. +func (c *Checker) yieldCycleToMembers(start int) bool { + if m := c.findMembersInCycle(start); m >= 0 { + r := &c.resolutions[start].typeResolution + if c.isYieldingTo(r.target, r.propertyName) { + c.markResolutionCycle(start) + return false + } + if t := &c.resolutions[m].typeResolution; r.propertyName == TypeSystemPropertyNameResolvedTypeArguments && t.target == r.target { + // The members of a type reference are available only once its type + // arguments are resolved, so entering the cycle at them fails too. + c.markResolutionCycle(start) + return false + } + if t := &c.resolutions[m].typeResolution; t.propertyName == TypeSystemPropertyNameStructuredMembers && c.isModuleTableType(t.target.(*Type)) { + t.restartHidden = true + c.markResolutionCycle(m) + return false + } + floor := m + if t := &c.resolutions[m].typeResolution; t.propertyName == TypeSystemPropertyNameStructuredMembers && m > start+1 && c.resolutions[m-1].key == memoKeyOf(t.target.(*Type), memoStructuredMembers) { + // The table's own computation, below its type resolution, must be + // visible too, so that reading the table finds it in progress. + floor = m - 1 + } + c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), floor) + return true + } + if !c.yieldCycle(start) { + c.markResolutionCycle(start) + return false + } + return true +} + +// findMembersInCycle returns the index in resolutions of the outermost +// resolution of a member table in progress above start, or -1. Member +// tables are available while they are resolved, so a cycle entered at its +// member table never fails. +func (c *Checker) findMembersInCycle(start int) int { + for i := start + 1; i < len(c.resolutions); i++ { + f := &c.resolutions[i] + if f.isTypeResolution && f.typeResolution.propertyName == TypeSystemPropertyNameStructuredMembers { + return i + } + if f.memberSymbol != nil { + return i + } + } + return -1 +} + +func (c *Checker) isYieldingTo(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + return slices.ContainsFunc(c.cycleYields, func(y cycleYield) bool { return y.target == target && y.propertyName == propertyName }) +} + +// beginCycleYield hides the resolutions in progress below floor until +// endCycleYield, which popping the resolution at end calls if it is not -1. +func (c *Checker) beginCycleYield(target TypeSystemEntity, propertyName TypeSystemPropertyName, end int, floor int) { + n := floor + c.cycleYields = append(c.cycleYields, cycleYield{ + end: end, + target: target, + propertyName: propertyName, + savedResolutionStart: c.resolutionStart, + savedVisibleStart: c.visibleStart, + savedVisibleSigs: c.visibleSignatures, + savedDepths: [3]depthLimit{c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth}, + savedReverseMapped: reverseMappedState{c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart}, + savedContextual: c.contextualInfos, + savedInference: c.inferenceContextInfos, + }) + // The contexts the hidden resolutions entered are hidden too, so that the + // recomputation is from scratch. + c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart = nil, nil, 0, 0 + c.contextualInfos, c.inferenceContextInfos = nil, nil + c.resolutionStart = n + c.visibleStart = n + c.visibleSignatures = len(c.signaturesResolving) + c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth = depthLimit{}, depthLimit{}, depthLimit{} +} + +func (c *Checker) endCycleYield() { + y := &c.cycleYields[len(c.cycleYields)-1] + c.resolutionStart = y.savedResolutionStart + c.visibleStart = y.savedVisibleStart + c.visibleSignatures = y.savedVisibleSigs + c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth = y.savedDepths[0], y.savedDepths[1], y.savedDepths[2] + r := y.savedReverseMapped + c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart = r.sourceStack, r.targetStack, r.expandingFlags, r.start + c.contextualInfos, c.inferenceContextInfos = y.savedContextual, y.savedInference + for _, sh := range y.shadowed { + c.resolutions[sh.index].shadowed = false + } + c.cycleYields[len(c.cycleYields)-1] = cycleYield{} + c.cycleYields = c.cycleYields[:len(c.cycleYields)-1] +} + +// markResolutionCycle records that the type resolution entries from start to +// the top of the stack form a cycle, so each of them fails. The failed +// results are kept, except that of a resolution yieldCycleToMembers computes +// again while it is in progress below: the computation below sets its own. +func (c *Checker) markResolutionCycle(start int) { + for i := start; i < len(c.resolutions); i++ { + if r := &c.resolutions[i].typeResolution; c.resolutions[i].isTypeResolution && r.result { + if !c.isRecomputedByYield(i) && r.memo != nil { + c.cycleParticipants = append(c.cycleParticipants, r.memo) + } + r.result = false + } + } + c.markTypeResolutionCircular(start) +} + +func (c *Checker) isRecomputedByYield(i int) bool { + for j := range c.cycleYields { + if c.cycleYields[j].end == i { + return true + } + } + return false +} + +// observeResolutionInProgress is for computations that are skipped rather +// than failed when re-entered. Skipping still observes the incomplete +// computation, so everything on the stack since it started is in a cycle. +func (c *Checker) observeResolutionInProgress(target TypeSystemEntity, propertyName TypeSystemPropertyName) { + if start := c.findResolutionCycleStartIndex(target, propertyName); start >= 0 { + c.markResolutionCycle(start) + } +} + +// isResolutionInProgress reports whether a resolution is on the stack, for +// computations that deliberately take another path to avoid a circularity. +// The answer depends on the incomplete resolution, so results cached while it +// is in progress must not outlive it, but nothing fails. +func (c *Checker) isResolutionInProgress(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + start := c.findResolutionCycleStartIndex(target, propertyName) + if start < 0 { + return false + } + c.markTypeResolutionCircular(start) + return true +} + +// isResolvingAnywhere reports whether the property of target is being +// resolved. A computation finding it so fails, as computing it from scratch +// would, so the results cached since it started are discarded when it +// finishes, like those of any other failure, and every caller computes them +// again and reports the failure. Unlike isResolutionInProgress, it searches +// the whole stack, for computations that would not otherwise stop. +func (c *Checker) isResolvingAnywhere(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + if i := c.resolvingAnywhereIndex(target, propertyName); i >= 0 { + c.markTypeResolutionCircular(i) + return true + } + return false +} + +// resolvingAnywhereIndex returns the index in resolutions of the visible +// resolution of the property of target in progress, or -1. +func (c *Checker) resolvingAnywhereIndex(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { + for i := c.typeResolutionTop - 1; i >= c.visibleStart; i = int(c.resolutions[i].prevTypeResolution) - 1 { + if r := &c.resolutions[i].typeResolution; r.target == target && r.propertyName == propertyName { + return i + } + } + return -1 +} + +// observeCircularHead is for computations where re-entering one in progress +// fails only that computation, while the others complete from its failed +// result. Which member fails then depends on which was entered first, so the +// cycle records its canonical member, the first in program order, and the +// head resolves that member first when it finishes; see popCircularHead. +// Everything else cached during the cycle is discarded like for +// isResolutionInProgress. It returns the index in resolutions of the head, or +// -1 if target is not in progress. +func (c *Checker) observeCircularHead(target TypeSystemEntity, propertyName TypeSystemPropertyName, compare func(a, b TypeSystemEntity) int) int { + start := c.findResolutionCycleStartIndex(target, propertyName) + if start < 0 { + return -1 + } + c.markTypeResolutionCircular(start) + head := &c.resolutions[start].typeResolution + canonical := core.OrElse(head.canonical, head.target) + for i := start + 1; i < len(c.resolutions); i++ { + if r := &c.resolutions[i].typeResolution; c.resolutions[i].isTypeResolution && r.propertyName == propertyName && compare(r.target, canonical) < 0 { + canonical = r.target + } + } + head.canonical = canonical + return start +} + +// addCycleParticipants keeps the results of the type resolutions from start +// to the top of the stack when the cycle in progress ends, as they would be +// kept had the resolution at start been entered first. +func (c *Checker) addCycleParticipants(start int) { + for i := start; i < len(c.resolutions); i++ { + if r := &c.resolutions[i].typeResolution; c.resolutions[i].isTypeResolution && r.result && !r.participant && r.memo != nil { + r.participant = true + c.cycleParticipants = append(c.cycleParticipants, r.memo) + } + } +} + +// popCircularHead pops a resolution that may head a cycle observed by +// observeCircularHead. It returns the cycle's canonical member when that is +// not the head itself, in which case everything cached since mark has been +// discarded, including the results of the cycle's participants, and the +// caller must resolve the canonical member before resolving the head again. +func (c *Checker) popCircularHead(mark discardMark) TypeSystemEntity { + r := c.topTypeResolution() + canonical := r.canonical + if canonical == r.target { + canonical = nil + } + if canonical != nil { + // Discard while the cycle is still in progress, so that the results + // of its participants are discarded too. + c.discardSince(mark) + } + c.popTypeResolution() + return canonical +} + +// enterSharedCurrentNode is enterCurrentNode for a node that shares the +// resolution of the enclosing node, small enough to inline for the common +// case. It reports false, changing nothing, if the node needs its own. +func (c *Checker) enterSharedCurrentNode(node *ast.Node) (savedCurrentNode, bool) { + save := savedCurrentNode{node: c.currentNode, resolution: c.currentNodeResolution} + if c.currentNodeResolution == 0 || c.currentNodeResolution != len(c.resolutions) || c.circularityStart != 0 || len(c.innerCycles) != 0 { + return save, false + } + c.currentNode = node + return save, true +} + +// exitSharedCurrentNode is exitCurrentNode for a node entered without a +// resolution of its own, when that ends no cycle. It reports false, changing +// nothing, otherwise. +func (c *Checker) exitSharedCurrentNode(save savedCurrentNode) bool { + if c.currentNodeResolution != save.resolution || c.circularityStart >= save.resolution || len(c.innerCycles) != 0 { + return false + } + c.currentNode = save.node + return true +} + +// enterCurrentNode makes node the node being checked, until the matching +// exitCurrentNode. Its resolution delimits the results that errors located at +// node (see reportAtCurrentNode) depend on. +func (c *Checker) enterCurrentNode(node *ast.Node) savedCurrentNode { + save := savedCurrentNode{node: c.currentNode, resolution: c.currentNodeResolution} + if c.circularityStart != 0 && c.circularityStart == c.currentNodeResolution && c.typeResolutionTop < c.currentNodeResolution { + // The results discarded when the current node is left depend on errors + // located at it, so a node within it must not reuse them either. + c.endCircularity() + } + c.currentNode = node + if c.currentNodeResolution != 0 && c.currentNodeResolution == len(c.resolutions) && c.circularityStart == 0 && len(c.innerCycles) == 0 { + // Nothing separates the node from the one enclosing it, so the + // resolution of that one stands in for it: a cycle through the node + // starts at that resolution, and nothing else can until the node is + // left, where exitCurrentNode ends it as popping the node's own + // resolution would. + return save + } + // The node's resolution shares the work of the one below it, as a type + // resolution does. + f := c.pushResolution() + parent := &c.resolutions[len(c.resolutions)-2] + f.depthStart = parent.depthStart + f.serial = parent.serial + c.currentNodeResolution = len(c.resolutions) + return save +} + +func (c *Checker) exitCurrentNode(save savedCurrentNode) { + if c.currentNodeResolution == save.resolution { + // The node had no resolution of its own; see enterCurrentNode. + c.endCyclesAt(save.resolution - 1) + c.currentNode = save.node + return + } + debug.Assert(c.currentNodeResolution == len(c.resolutions), "resolutions left on the stack") + c.dropResolution(c.currentNodeResolution - 1) + c.currentNode = save.node + c.currentNodeResolution = save.resolution +} + +// enterQuery starts a query made outside of checking, unless one is already +// in progress. Results that depend on errors located at the current node are +// discarded when the query finishes (see reportAtCurrentNode), so a query +// that reads results back from caches after computing them must do so before +// then. +func (c *Checker) enterQuery() (savedCurrentNode, bool) { + if c.memoTop != 0 || c.currentNodeResolution != 0 { + return savedCurrentNode{}, false + } + return c.enterCurrentNode(c.currentNode), true +} + +func (c *Checker) exitQuery(save savedCurrentNode, ok bool) { + if ok { + c.exitCurrentNode(save) + } +} + +type savedCurrentNode struct { + node *ast.Node + resolution int +} + +// markCurrentNodeCircular records that results cached until the current node +// is left depend on that node. +func (c *Checker) markCurrentNodeCircular() { + if c.currentNodeResolution != 0 { + c.extendCircularity(c.currentNodeResolution) + } +} + +// markTypeResolutionCircular records that the computations from start to the +// top of the stack observed the incomplete resolution at start without +// failing, so results cached while it is in progress are discarded when it +// finishes. +func (c *Checker) markTypeResolutionCircular(start int) { + c.recordFromCheck() + if !c.checking { + c.memoCycle(int(c.resolutions[start].prevMemo)) + } + c.markCircular(start) +} + +// keepsResultInCycle reports whether the type resolution at index n, which +// observed the cycles whose lowest head is observed (see Checker.observedHead), +// computes what it computes first from scratch although a cycle is in +// progress, so that its result is kept as a participant of the cycle: +// - The resolution re-entered a hidden resolution of itself, which a +// computation from scratch of the outer one always does, and what it +// observed in progress was all entered by the outer one, so its result is +// what the outer one computes first from scratch. +// - The resolution is the one a cycle yield computes again from scratch, +// with everything below it hidden, and it observed nothing hidden. +func (c *Checker) keepsResultInCycle(n int, f *resolution, observed int32) bool { + r := &f.typeResolution + if r.outerSelf != 0 && observed != 0 && observed >= r.outerSelf && int(observed) <= n { + return true + } + if len(c.cycleYields) != 0 { + // The innermost yield hides what is below visibleStart. + if floor := c.visibleStart; n >= floor && int(f.prevTypeResolution) <= floor && (observed == 0 || int(observed) > floor) { + return true + } + } + return false +} + +func minObservedHead(a int32, b int32) int32 { + if a == 0 || b != 0 && b < a { + return b + } + return a +} + +// markCircular records that the computations from the resolution at start to +// the top of the stack observed the incomplete computation at start, so +// results cached while it is in progress are discarded when it finishes. +func (c *Checker) markCircular(start int) { + if c.currentNodeErrorCollectors != 0 { + c.currentNodeErrorsCyclic = true + } + c.extendCircularity(start + 1) +} + +// depthLimit counts the nesting of a recursion that is cut short at a fixed +// depth. How deep a computation may go then depends on how deep it was +// entered, so a computation cut short keeps its result only if it started +// counting. +type depthLimit struct { + depth int32 + start int32 // Index in resolutions of the computation that started counting +} + +// depthLimitReached reports whether l is at limit, in which case the +// computations since the one that started counting are marked circular. +func (c *Checker) depthLimitReached(l *depthLimit, limit int32) bool { + if l.depth < limit { + return false + } + c.markCircular(int(l.start)) + return true +} + +func (c *Checker) enterDepthLimit(l *depthLimit) { + if l.depth == 0 { + l.start = int32(len(c.resolutions) - 1) + } + l.depth++ +} + +// exitDepthLimit leaves a level of l. If counting started with no computation +// in progress, as in a query, reaching the limit marked a cycle headed at the +// bottom of the stack, which never finishes, so the cycle ends when counting +// does instead. +func (c *Checker) exitDepthLimit(l *depthLimit) { + l.depth-- + if l.depth == 0 { + if l.start == 0 { + c.endCyclesAt(0) + } + l.start = 0 + } +} + +/** + * Pop an entry from the type resolution stack and return its associated result value. The result value will + * be true if no circularities were detected, or false if a circularity was found. + */ +func (c *Checker) popTypeResolution() bool { + n := len(c.resolutions) - 1 + debug.Assert(c.typeResolutionTop == n+1, "resolutions left above a type resolution") + f := &c.resolutions[n] + result := f.typeResolution.result + observed := c.observedHead + if f.prevTypeResolution != 0 { + c.observedHead = minObservedHead(f.prevObservedHead, observed) + } else { + // Only an enclosing type resolution reads the cycle heads observed. + c.observedHead = 0 + } + if r := &f.typeResolution; result && !r.participant && r.memo != nil && c.circularityStart != 0 && c.keepsResultInCycle(n, f, observed) { + r.participant = true + c.cycleParticipants = append(c.cycleParticipants, r.memo) + } + c.typeResolutionTop = int(f.prevTypeResolution) + c.dropResolution(n) + if len(c.cycleYields) != 0 && c.cycleYields[len(c.cycleYields)-1].end == n { + c.endCycleYield() + } + return result +} + +// beginTypeResolution starts the resolution of propertyName for target, which +// re-entering detects as a cycle. Its resolution shares the work of the +// resolution below it. memo caches its result, if any. +func (c *Checker) beginTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName, memo *memoHeader) { + f := c.pushResolution() + parent := &c.resolutions[len(c.resolutions)-2] + f.depthStart = parent.depthStart + f.serial = parent.serial + f.prevMemo = int32(c.memoTop) + f.isTypeResolution = true + f.prevTypeResolution = int32(c.typeResolutionTop) + f.prevObservedHead = c.observedHead + c.observedHead = 0 + f.typeResolution.target = target + f.typeResolution.memo = memo + f.typeResolution.propertyName = propertyName + f.typeResolution.result = true + c.typeResolutionTop = len(c.resolutions) +} + +// topTypeResolution returns the innermost resolution, which must be the +// innermost resolution. +func (c *Checker) topTypeResolution() *TypeResolution { + debug.Assert(c.typeResolutionTop == len(c.resolutions), "resolutions left above a type resolution") + return &c.resolutions[len(c.resolutions)-1].typeResolution } func (c *Checker) reportCircularityError(symbol *ast.Symbol) *Type { @@ -19377,7 +21302,7 @@ func (c *Checker) getPropertiesOfType(t *Type) []*ast.Symbol { func (c *Checker) getPropertiesOfObjectType(t *Type) []*ast.Symbol { if t.flags&TypeFlagsObject != 0 { - return c.resolveStructuredTypeMembers(t).getProperties() + return c.resolveStructuredTypeMembers(t).getProperties(c) } return nil } @@ -19408,28 +21333,31 @@ func (c *Checker) getLazyStateOfType(t *Type) *LazyState { func (c *Checker) getPropertiesOfUnionOrIntersectionType(t *Type) []*ast.Symbol { d := t.AsUnionOrIntersectionType() - if d.resolvedProperties == nil { - var checked collections.Set[string] - props := []*ast.Symbol{} - for _, current := range d.types { - for _, prop := range c.getPropertiesOfType(current) { - if !checked.Has(prop.Name()) { - checked.Add(prop.Name()) - combinedProp := c.getPropertyOfUnionOrIntersectionType(t, prop.Name(), t.flags&TypeFlagsIntersection != 0 /*skipObjectFunctionPropertyAugment*/) - if combinedProp != nil { - props = append(props, combinedProp) - } + if props := d.resolvedProperties.cached(c); props != nil { + return props + } + d.resolvedProperties.begin(c) + var checked collections.Set[string] + props := []*ast.Symbol{} + for _, current := range d.types { + for _, prop := range c.getPropertiesOfType(current) { + if !checked.Has(prop.Name()) { + checked.Add(prop.Name()) + combinedProp := c.getPropertyOfUnionOrIntersectionType(t, prop.Name(), t.flags&TypeFlagsIntersection != 0 /*skipObjectFunctionPropertyAugment*/) + if combinedProp != nil { + props = append(props, combinedProp) } } - // The properties of a union type are those that are present in all constituent types, so - // we only need to check the properties of the first type without index signature - if t.flags&TypeFlagsUnion != 0 && len(c.getIndexInfosOfType(current)) == 0 { - break - } } - d.resolvedProperties = props + // The properties of a union type are those that are present in all constituent types, so + // we only need to check the properties of the first type without index signature + if t.flags&TypeFlagsUnion != 0 && len(c.getIndexInfosOfType(current)) == 0 { + break + } } - return d.resolvedProperties + d.resolvedProperties.set(c, props) + c.endMemo() + return props } func (c *Checker) getPropertyOfType(t *Type, name string) *ast.Symbol { @@ -19454,7 +21382,7 @@ func (c *Checker) getPropertyOfTypeEx(t *Type, name string, skipObjectFunctionPr } } resolved := c.resolveStructuredTypeMembers(t) - symbol := resolved.getMember(name) + symbol := resolved.getMember(c, name) if symbol != nil { if !includeTypeOnlyMembers && t.symbol != nil && t.symbol.Flags()&ast.SymbolFlagsValueModule != 0 && c.moduleSymbolLinks.Get(t.symbol).typeOnlyExportStarMap[name] != nil { // If this is the type of a module, `resolved.members.get(name)` might have effectively skipped over @@ -19504,9 +21432,15 @@ func (c *Checker) getPropertyOfTypeEx(t *Type, name string, skipObjectFunctionPr // means that base classes of a class or interface can access members declared in the class or interface // during its resolution without causing a circularity error. Members resolved by this function are // eventually propagated into the resolved members of the class or interface. +// +// The answer depends on the resolution in progress, so it is observed as a +// cycle through it. func (c *Checker) getDeclaredPropertyOfResolvingType(t *Type, name string) *ast.Symbol { for i := len(c.resolvingObjectTypeStack) - 1; i >= 0; i-- { if c.resolvingObjectTypeStack[i].t == t { + if !c.isResolutionInProgress(t, TypeSystemPropertyNameStructuredMembers) { + return nil + } resolved := c.resolvingObjectTypeStack[i].resolvedMembers.Get(name) if resolved == nil { if symbol := c.resolveDeclaredMembers(getTargetType(t)).declaredMembers.Get(name); symbol != nil && c.isNamedMember(symbol, name) { @@ -19615,63 +21549,273 @@ func (c *Checker) findApplicableIndexInfo(indexInfos []*IndexInfo, keyType *Type applicableInfos = append(applicableInfos, info) } } - // When more than one index signature is applicable we create a synthetic IndexInfo. Instead of computing - // the intersected key type, we just use unknownType for the key type as nothing actually depends on the - // keyType property of the returned IndexInfo. - switch len(applicableInfos) { - case 0: - if stringIndexInfo != nil && c.isApplicableIndexType(keyType, c.stringType) { - return stringIndexInfo + // When more than one index signature is applicable we create a synthetic IndexInfo. Instead of computing + // the intersected key type, we just use unknownType for the key type as nothing actually depends on the + // keyType property of the returned IndexInfo. + switch len(applicableInfos) { + case 0: + if stringIndexInfo != nil && c.isApplicableIndexType(keyType, c.stringType) { + return stringIndexInfo + } + return nil + case 1: + return applicableInfos[0] + default: + isReadonly := true + types := make([]*Type, len(applicableInfos)) + for i, info := range applicableInfos { + types[i] = info.valueType + if !info.isReadonly { + isReadonly = false + } + } + return c.newIndexInfo(c.unknownType, c.getIntersectionType(types), isReadonly, nil, nil) + } +} + +func (c *Checker) isApplicableIndexType(source *Type, target *Type) bool { + // A 'string' index signature applies to types assignable to 'string' or 'number', and a 'number' index + // signature applies to types assignable to 'number', `${number}` and numeric string literal types. + return c.isTypeAssignableTo(source, target) || + target == c.stringType && c.isTypeAssignableTo(source, c.numberType) || + target == c.numberType && (source == c.numericStringType || source.flags&TypeFlagsStringLiteral != 0 && isNumericLiteralName(getStringLiteralValue(source))) +} + +func (c *Checker) resolveStructuredTypeMembers(t *Type) *StructuredType { + if t.objectFlags&ObjectFlagsMembersResolved != 0 && !c.observingMemos { + return t.asResolvedStructuredType() + } + return c.resolveStructuredTypeMembersSlow(t) +} + +// resolveStructuredTypeMembersSlow is the part of resolveStructuredTypeMembers +// past reading resolved members, out of line so that the rest inlines. +func (c *Checker) resolveStructuredTypeMembersSlow(t *Type) *StructuredType { + key := memoKeyOf(t, memoStructuredMembers) + if t.objectFlags&ObjectFlagsMembersResolved != 0 { + // Resolved members are only read. + c.observeMemo(key) + return t.AsStructuredType() + } + published := false + enclosing, inProgress := c.resolvingAnyIndex(key) + if !inProgress { + enclosing = -1 + } else { + // Resolving members may observe the type itself, whose members are + // then incomplete. + if c.isModuleTableType(t) { + if start := c.observeCircularHead(t, TypeSystemPropertyNameStructuredMembers, c.compareModuleTables); start >= 0 { + // When the table is canonical, the computations that read + // its partial members keep their results, as they would + // had the table been entered first. + c.addCycleParticipants(start) + } + } else { + c.isResolutionInProgress(t, TypeSystemPropertyNameStructuredMembers) + } + published = c.resolutions[enclosing].membersPublished + if j, ok := c.resolvingGet(key); published && ok && int(j) < c.visibleStart { + // The members are being resolved below the cycle yield in + // progress, which then sees whatever part of them that + // resolution has published, rather than compute them from + // scratch, so the yield fails. If none are published, the + // nested resolution below computes them from scratch instead. + c.markResolutionCycle(c.visibleStart) + } + } + c.beginMemo(key) + if !published { + c.resolveStructuredTypeMembersUncached(t, enclosing) + } + c.endMemo() + return t.AsStructuredType() +} + +// resolveStructuredTypeMembersUncached resolves the members of t in the memo +// just begun for them. Many kinds of types make members available before +// they are complete, through publishStructuredTypeMembers, so the resolution +// is on the stack, but never fails. The members are resolved only once the +// outermost resolution of them completes. A nested one, which re-entering +// the members before any are available starts, makes its result available +// to the rest of the enclosing resolution at index enclosing, which may be +// hidden by a cycle yield. +func (c *Checker) resolveStructuredTypeMembersUncached(t *Type, enclosing int) { + outermost := enclosing < 0 + if outermost && c.isModuleTableType(t) { + c.resolveModuleTableMembers(t) + return + } + c.beginTypeResolution(t, TypeSystemPropertyNameStructuredMembers, nil) + defer func() { + c.popTypeResolution() + if outermost { + t.objectFlags |= ObjectFlagsMembersResolved + } else { + c.resolutions[enclosing].membersPublished = true + } + if c.logResults() { + c.logMembersDiscard(t) + } + }() + switch { + case t.flags&TypeFlagsObject != 0: + switch { + case t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0: + c.resolveObjectTypeMembers(t) + case t.objectFlags&ObjectFlagsReverseMapped != 0: + c.resolveReverseMappedTypeMembers(t) + case t.objectFlags&ObjectFlagsAnonymous != 0: + c.resolveAnonymousTypeMembers(t) + case t.objectFlags&ObjectFlagsMapped != 0: + c.resolveMappedTypeMembers(t) + default: + panic("Unhandled case in resolveStructuredTypeMembers") + } + case t.flags&TypeFlagsUnion != 0: + c.resolveUnionTypeMembers(t) + case t.flags&TypeFlagsIntersection != 0: + c.resolveIntersectionTypeMembers(t) + default: + panic("Unhandled case in resolveStructuredTypeMembers") + } +} + +// markMembersPublished records that the members of t, whose resolution is +// in progress, are available to computations re-entering it. +func (c *Checker) markMembersPublished(t *Type) { + i, ok := c.resolvingAnyIndex(memoKeyOf(t, memoStructuredMembers)) + debug.Assert(ok, "members published outside their resolution") + c.resolutions[i].membersPublished = true +} + +// publishStructuredTypeMembers sets the members of t while they are being +// resolved, making them available to computations re-entering the resolution +// before it completes. +func (c *Checker) publishStructuredTypeMembers(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) { + // Listing the properties may re-enter the resolution, which then sees + // the members. + c.markMembersPublished(t) + c.setStructuredTypeData(t, members, callSignatures, constructSignatures, indexInfos) +} + +// isModuleTableType reports whether t is the type of a module object, whose +// members are the exports of the module. +func (c *Checker) isModuleTableType(t *Type) bool { + if t.objectFlags&ObjectFlagsAnonymous == 0 || t.symbol == nil || t.AsObjectType().target != nil { + return false + } + flags := c.getMergedSymbol(t.symbol).Flags() + return flags&ast.SymbolFlagsValueModule != 0 && flags&(ast.SymbolFlagsFunction|ast.SymbolFlagsClass|ast.SymbolFlagsEnum|ast.SymbolFlagsTypeLiteral) == 0 +} + +// compareModuleTables orders the resolutions of module object types in a +// cycle by the declarations of their modules, before any other resolutions. +func (c *Checker) compareModuleTables(a, b TypeSystemEntity) int { + ta, tb := a.(*Type), b.(*Type) + ma, mb := c.isModuleTableType(ta), c.isModuleTableType(tb) + switch { + case ma && mb: + return c.compareSymbols(ta.symbol, tb.symbol) + case ma: + return -1 + case mb: + return 1 + } + return 0 +} + +// resolveModuleTableMembers resolves the members of a module object type. +// Members are available while they are resolved, so module tables that +// read each other's members see the partial members of whichever was +// entered first. The table of the module first in program order is always +// resolved first, discarding whatever was computed starting from another, +// and a table that a cycle entered elsewhere passes through is resolved +// again as if the cycle had been entered at the table. +func (c *Checker) resolveModuleTableMembers(t *Type) { + mark := c.markDiscard() + hidden := false + for { + c.beginTypeResolution(t, TypeSystemPropertyNameStructuredMembers, nil) + c.resolveAnonymousTypeMembers(t) + restart := c.topTypeResolution().restartHidden && !hidden + if restart { + // Discard while the cycle is still in progress, as + // popCircularHead does. + c.discardSince(mark) + } + canonical := c.popCircularHead(mark) + if canonical == nil && !restart { + break } - return nil - case 1: - return applicableInfos[0] - default: - isReadonly := true - types := make([]*Type, len(applicableInfos)) - for i, info := range applicableInfos { - types[i] = info.valueType - if !info.isReadonly { - isReadonly = false - } + c.clearStructuredMembers(t) + key := memoKeyOf(t, memoStructuredMembers) + i, _ := c.resolvingGet(key) + c.resolutions[i].membersPublished = false + if canonical != nil { + c.resolveStructuredTypeMembers(canonical.(*Type)) + continue } - return c.newIndexInfo(c.unknownType, c.getIntersectionType(types), isReadonly, nil, nil) + // A cycle entered below the table passed through it, so the table + // is resolved again as if it had been entered first: with the + // computations in progress below it hidden. + hidden = true + c.beginCycleYield(t, TypeSystemPropertyNameStructuredMembers, -1, int(i)) + } + if hidden { + c.endCycleYield() + } + t.objectFlags |= ObjectFlagsMembersResolved + c.releaseDiscardMark(mark) + if c.logResults() { + c.logMembersDiscard(t) } } -func (c *Checker) isApplicableIndexType(source *Type, target *Type) bool { - // A 'string' index signature applies to types assignable to 'string' or 'number', and a 'number' index - // signature applies to types assignable to 'number', `${number}` and numeric string literal types. - return c.isTypeAssignableTo(source, target) || - target == c.stringType && c.isTypeAssignableTo(source, c.numberType) || - target == c.numberType && (source == c.numericStringType || source.flags&TypeFlagsStringLiteral != 0 && isNumericLiteralName(getStringLiteralValue(source))) +func (c *Checker) clearStructuredMembers(t *Type) { + t.objectFlags &^= ObjectFlagsMembersResolved + data := t.AsStructuredType() + data.members = nil + data.properties = nil + if data.extra != nil { + data.extra.signatures = nil + data.extra.callSignatureCount = 0 + data.extra.indexInfos = nil + } } -func (c *Checker) resolveStructuredTypeMembers(t *Type) *StructuredType { - if t.objectFlags&ObjectFlagsMembersResolved == 0 { - switch { - case t.flags&TypeFlagsObject != 0: - switch { - case t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0: - c.resolveObjectTypeMembers(t) - case t.objectFlags&ObjectFlagsReverseMapped != 0: - c.resolveReverseMappedTypeMembers(t) - case t.objectFlags&ObjectFlagsAnonymous != 0: - c.resolveAnonymousTypeMembers(t) - case t.objectFlags&ObjectFlagsMapped != 0: - c.resolveMappedTypeMembers(t) - default: - panic("Unhandled case in resolveStructuredTypeMembers") - } - case t.flags&TypeFlagsUnion != 0: - c.resolveUnionTypeMembers(t) - case t.flags&TypeFlagsIntersection != 0: - c.resolveIntersectionTypeMembers(t) - default: - panic("Unhandled case in resolveStructuredTypeMembers") +// logMembersDiscard discards the members of t when the cycle in progress +// ends, like any other result cached during the cycle, so that they are +// resolved again from scratch when next requested. +// +//go:noinline +func (c *Checker) logMembersDiscard(t *Type) { + c.logRestore(func() { + if _, ok := c.resolvingAnyIndex(memoKeyOf(t, memoStructuredMembers)); ok { + // An enclosing resolution of the same members sets them again. + return } - } - return t.AsStructuredType() + c.clearStructuredMembers(t) + if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0 { + t.AsTypeReference().lazy = nil + } + }) +} + +// logPropertySlotDiscard discards the property in slot index of t, filled on +// first use during a cycle, when the cycle ends. The property may be one of a +// base type whose members the cycle discards. +// +//go:noinline +func (c *Checker) logPropertySlotDiscard(t *StructuredType, lazy *LazyState, index int) { + properties := t.properties + c.logRestore(func() { + properties[index] = nil + lazy.propertiesResolved = false + if t.AsType().AsTypeReference().lazy == lazy { + t.members = nil + } + }) } func (c *Checker) resolveObjectTypeMembers(t *Type) { @@ -19728,7 +21872,7 @@ func (c *Checker) resolveObjectTypeMembers(t *Type) { return findIndexInfo(indexInfos, info.keyType) == nil })) } - c.setStructuredTypeMembers(t, nil, callSignatures, constructSignatures, indexInfos) + c.setStructuredTypeData(t, nil, callSignatures, constructSignatures, indexInfos) lazyState := c.lazyStateArena.New() lazyState.layout = layout lazyState.mapper = mapper @@ -19759,15 +21903,12 @@ func (c *Checker) getMemberLayout(t *Type, baseTypes []*Type) *MemberLayout { } source := c.getTargetType(t) key := c.getMemberLayoutKey(source, baseTypes) - layout := c.memberLayoutCache[key] - if layout == nil { - layout = c.createMemberLayout(source, baseTypes) - if c.memberLayoutCache == nil { - c.memberLayoutCache = make(map[CacheHashKey]*MemberLayout) - } - c.memberLayoutCache[key] = layout + if layout, ok := c.memberLayoutCache.cached(c, key); ok { + return layout } - return layout + return c.memberLayoutCache.compute(c, key, func() *MemberLayout { + return c.createMemberLayout(source, baseTypes) + }) } func (c *Checker) getMemberLayoutKey(t *Type, baseTypes []*Type) CacheHashKey { @@ -19846,17 +21987,36 @@ func findIndexInfo(indexInfos []*IndexInfo, keyType *Type) *IndexInfo { } func (c *Checker) getBaseTypes(t *Type) []*Type { + if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsTuple) == 0 { + return nil + } + if data := t.AsInterfaceType(); data.baseTypesResolved { + // Observing the result is what re-entering its computation amounts + // to, without the resolution. Walks over base types such as + // hasBaseType revisit shared bases many times. + if c.memoActive() { + c.observeMemo(memoKeyOf(t, memoBaseTypes)) + } + return data.resolvedBaseTypes.cached(c) + } + c.beginMemo(memoKeyOf(t, memoBaseTypes)) + result := c.getBaseTypesUncached(t) + c.endMemo() + return result +} + +func (c *Checker) getBaseTypesUncached(t *Type) []*Type { if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsTuple) == 0 { return nil } data := t.AsInterfaceType() if !data.baseTypesResolved { - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseTypes) { - return data.resolvedBaseTypes + if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseTypes, &data.resolvedBaseTypes.memoHeader) { + return data.resolvedBaseTypes.cached(c) } switch { case t.objectFlags&ObjectFlagsTuple != 0: - data.resolvedBaseTypes = []*Type{c.getTupleBaseType(t)} + data.resolvedBaseTypes.set(c, []*Type{c.getTupleBaseType(t)}) case t.symbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface) != 0: if t.symbol.Flags()&ast.SymbolFlagsClass != 0 { c.resolveBaseTypesOfClass(t) @@ -19880,8 +22040,11 @@ func (c *Checker) getBaseTypes(t *Type) []*Type { // See https://github.com/microsoft/TypeScript/issues/16861 for an example. t.objectFlags &^= ObjectFlagsMembersResolved data.baseTypesResolved = true + if c.logResults() { + c.discardLog = append(c.discardLog, discardEntry{memo: &data.resolvedBaseTypes.memoHeader, restore: func() { data.baseTypesResolved = false }}) + } } - return data.resolvedBaseTypes + return data.resolvedBaseTypes.cached(c) } func (c *Checker) getTupleBaseType(t *Type) *Type { @@ -19942,7 +22105,7 @@ func (c *Checker) resolveBaseTypesOfClass(t *Type) { c.error(t.symbol.ValueDeclaration(), diagnostics.Type_0_recursively_references_itself_as_a_base_type, c.TypeToString(t)) return } - t.AsInterfaceType().resolvedBaseTypes = []*Type{reducedBaseType} + t.AsInterfaceType().resolvedBaseTypes.set(c, []*Type{reducedBaseType}) } func getBaseTypeNodeOfClass(t *Type) *ast.Node { @@ -19981,7 +22144,7 @@ func (c *Checker) getSignatureInstantiation(sig *Signature, typeArguments []*Typ newReturnType := c.getOrCreateTypeFromSignature(newReturnSignature) newReturnType.AsObjectType().mapper = instantiatedSignature.mapper newInstantiatedSignature := c.cloneSignature(instantiatedSignature) - newInstantiatedSignature.resolvedReturnType = newReturnType + newInstantiatedSignature.resolvedReturnType.intern(newReturnType) return newInstantiatedSignature } } @@ -19998,10 +22161,12 @@ func (c *Checker) cloneSignature(sig *Signature) *Signature { func (c *Checker) getSignatureInstantiationWithoutFillingInTypeArguments(sig *Signature, typeArguments []*Type) *Signature { key := CachedSignatureKey{sig: sig, key: getTypeListKey(typeArguments)} - instantiation := c.cachedSignatures[key] + instantiation, _ := c.cachedSignatures.cached(c, key) if instantiation == nil { + c.cachedSignatures.begin(c, key) instantiation = c.createSignatureInstantiation(sig, typeArguments) - c.cachedSignatures[key] = instantiation + c.cachedSignatures.set(c, key, instantiation) + c.endMemo() } return instantiation } @@ -20079,10 +22244,12 @@ func (c *Checker) getErasedSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyErased} - erased := c.cachedSignatures[key] + erased, _ := c.cachedSignatures.cached(c, key) if erased == nil { + c.cachedSignatures.begin(c, key) erased = c.instantiateSignatureEx(signature, newArrayToSingleTypeMapper(signature.TypeParameters(), c.anyType), true /*eraseTypeParameters*/) - c.cachedSignatures[key] = erased + c.cachedSignatures.set(c, key, erased) + c.endMemo() } return erased } @@ -20092,10 +22259,12 @@ func (c *Checker) getCanonicalSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyCanonical} - canonical := c.cachedSignatures[key] + canonical, _ := c.cachedSignatures.cached(c, key) if canonical == nil { + c.cachedSignatures.begin(c, key) canonical = c.createCanonicalSignature(signature) - c.cachedSignatures[key] = canonical + c.cachedSignatures.set(c, key, canonical) + c.endMemo() } return canonical } @@ -20122,9 +22291,10 @@ func (c *Checker) getBaseSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyBase} - if cached := c.cachedSignatures[key]; cached != nil { + if cached, _ := c.cachedSignatures.cached(c, key); cached != nil { return cached } + c.cachedSignatures.begin(c, key) baseConstraintMapper := newTypeMapper(typeParameters, core.Map(typeParameters, func(tp *Type) *Type { return core.OrElse(c.getConstraintOfTypeParameter(tp), c.unknownType) })) @@ -20139,7 +22309,8 @@ func (c *Checker) getBaseSignature(signature *Signature) *Signature { // and then apply a type eraser to remove any remaining circularly dependent type parameters baseConstraints = c.instantiateTypes(baseConstraints, newArrayToSingleTypeMapper(typeParameters, c.anyType)) result := c.instantiateSignatureEx(signature, newTypeMapper(typeParameters, baseConstraints), true /*eraseTypeParameters*/) - c.cachedSignatures[key] = result + c.cachedSignatures.set(c, key, result) + c.endMemo() return result } @@ -20185,7 +22356,7 @@ func (c *Checker) resolveBaseTypesOfInterface(t *Type) { if !c.isErrorType(baseType) { if c.isValidBaseType(baseType) { if t != baseType && !c.hasBaseType(baseType, t) { - data.resolvedBaseTypes = append(data.resolvedBaseTypes, baseType) + data.resolvedBaseTypes.set(c, append(data.resolvedBaseTypes.cached(c), baseType)) } else { c.reportCircularBaseType(declaration, t) } @@ -20299,16 +22470,28 @@ func (c *Checker) addInheritedMembers(symbols ast.SymbolTable, baseSymbols []*as } func (c *Checker) resolveDeclaredMembers(t *Type) *InterfaceType { + d := t.AsInterfaceType() + key := memoKeyOf(t, memoDeclaredMembers) + if d.declaredMembersResolved { + c.observeFlagMemo(key) + return d + } + c.beginMemo(key) + c.resolveDeclaredMembersUncached(t) + c.endMemo() + return d +} + +func (c *Checker) resolveDeclaredMembersUncached(t *Type) { d := t.AsInterfaceType() if !d.declaredMembersResolved { members := c.getMembersOfSymbol(t.symbol) - d.declaredMembersResolved = true + c.setFlagMemoValue(memoKeyOf(t, memoDeclaredMembers), &d.declaredMembersResolved, true) d.declaredMembers = members d.declaredCallSignatures = c.getSignaturesOfSymbol(d.declaredMembers.Get(ast.InternalSymbolNameCall)) d.declaredConstructSignatures = c.getSignaturesOfSymbol(d.declaredMembers.Get(ast.InternalSymbolNameNew)) d.declaredIndexInfos = c.getIndexInfosOfSymbol(t.symbol) } - return d } func (c *Checker) getIndexInfosOfSymbol(symbol *ast.Symbol) []*IndexInfo { @@ -20523,9 +22706,20 @@ func (c *Checker) getSignaturesOfSymbol(symbol *ast.Symbol) []*Signature { } func (c *Checker) getSignatureFromDeclaration(declaration *ast.Node) *Signature { + signature := c.getSignatureFromDeclarationUncontextual(declaration) + if c.isContextSensitiveFunctionOrObjectLiteralMethod(declaration) { + c.assignContextualParameterTypesOfFunction(declaration, CheckModeNormal) + } + return signature +} + +// getSignatureFromDeclarationUncontextual returns the signature of a +// declaration without the contextual typing that completes the signatures +// of context-sensitive functions. +func (c *Checker) getSignatureFromDeclarationUncontextual(declaration *ast.Node) *Signature { links := c.signatureLinks.Get(declaration) - if links.resolvedSignature != nil { - return links.resolvedSignature + if links.resolvedSignature.cached(c) != nil { + return links.resolvedSignature.cached(c) } var parameters []*ast.Symbol var flags SignatureFlags @@ -20594,8 +22788,14 @@ func (c *Checker) getSignatureFromDeclaration(declaration *ast.Node) *Signature if ast.IsConstructorTypeNode(declaration) && ast.HasSyntacticModifier(declaration, ast.ModifierFlagsAbstract) || ast.IsConstructorDeclaration(declaration) && ast.HasSyntacticModifier(declaration.Parent, ast.ModifierFlagsAbstract) { flags |= SignatureFlagsAbstract } - links.resolvedSignature = c.newSignature(flags, declaration, typeParameters, thisParameter, parameters, nil /*resolvedReturnType*/, nil /*resolvedTypePredicate*/, minArgumentCount) - return links.resolvedSignature + if existing := links.resolvedSignature.cached(c); existing != nil { + // Computing the signature reached the enclosing call, which + // contextually typed the function with a signature of its own, as + // when the call is checked first. Keep that one. + return existing + } + links.resolvedSignature.set(c, c.newSignature(flags, declaration, typeParameters, thisParameter, parameters, nil /*resolvedReturnType*/, nil /*resolvedTypePredicate*/, minArgumentCount)) + return links.resolvedSignature.cached(c) } func (c *Checker) getTypeParametersFromDeclaration(declaration *ast.Node) []*Type { @@ -20688,10 +22888,30 @@ func isLateBindableAST(node *ast.Node) bool { } func (c *Checker) getReturnTypeOfSignature(sig *Signature) *Type { - if sig.resolvedReturnType != nil { - return sig.resolvedReturnType + if t := sig.resolvedReturnType.cached(c); t != nil { + return t + } + sig.resolvedReturnType.begin(c) + result := c.getReturnTypeOfSignatureUncached(sig) + c.endMemo() + return result +} + +func (c *Checker) getReturnTypeOfSignatureUncached(sig *Signature) *Type { + if sig.resolvedReturnType.cached(c) != nil { + return sig.resolvedReturnType.cached(c) + } + if d := sig.declaration; d != nil && sig.target == nil && ast.IsGetAccessorDeclaration(d) && d.Type() == nil { + // The type of the accessor infers the same return type separately, and + // is what checking the getter resolves first. Resolved from within + // this return type instead, a cycle through the accessor would be + // detected at the accessor rather than here. + c.getTypeOfSymbol(c.getSymbolOfDeclaration(d)) + if sig.resolvedReturnType.cached(c) != nil { + return sig.resolvedReturnType.cached(c) + } } - if !c.pushTypeResolution(sig, TypeSystemPropertyNameResolvedReturnType) { + if !c.pushTypeResolution(sig, TypeSystemPropertyNameResolvedReturnType, &sig.resolvedReturnType.memoHeader) { return c.errorType } var t *Type @@ -20716,25 +22936,31 @@ func (c *Checker) getReturnTypeOfSignature(sig *Signature) *Type { t = c.getOptionalType(t, false /*isProperty*/) } if !c.popTypeResolution() { - if sig.declaration != nil { - typeNode := sig.declaration.Type() - if typeNode != nil { - c.error(typeNode, diagnostics.Return_type_annotation_circularly_references_itself) - } else if c.noImplicitAny { - name := ast.GetNameOfDeclaration(sig.declaration) - if name != nil { - c.error(name, diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, scanner.DeclarationNameToString(name)) - } else { - c.error(sig.declaration, diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions) - } + t = c.circularReturnType(sig) + } + if sig.resolvedReturnType.cached(c) == nil { + sig.resolvedReturnType.set(c, t) + } + return sig.resolvedReturnType.cached(c) +} + +// circularReturnType reports a return type that depends on itself and returns +// the type it resolves to instead. +func (c *Checker) circularReturnType(sig *Signature) *Type { + if sig.declaration != nil { + typeNode := sig.declaration.Type() + if typeNode != nil { + c.error(typeNode, diagnostics.Return_type_annotation_circularly_references_itself) + } else if c.noImplicitAny { + name := ast.GetNameOfDeclaration(sig.declaration) + if name != nil { + c.error(name, diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, scanner.DeclarationNameToString(name)) + } else { + c.error(sig.declaration, diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions) } } - t = c.anyType } - if sig.resolvedReturnType == nil { - sig.resolvedReturnType = t - } - return sig.resolvedReturnType + return c.anyType } func (c *Checker) getNonCircularReturnTypeOfSignature(sig *Signature) *Type { @@ -21339,22 +23565,22 @@ func (c *Checker) instantiateIndexInfo(info *IndexInfo, m *TypeMapper) *IndexInf func (c *Checker) resolveAnonymousTypeMembers(t *Type) { d := t.AsObjectType() if d.target != nil { - c.setStructuredTypeMembers(t, nil, nil, nil, nil) + c.publishStructuredTypeMembers(t, nil, nil, nil, nil) members := c.createInstantiatedSymbolTable(c.getPropertiesOfObjectType(d.target), d.mapper) callSignatures := c.instantiateSignatures(c.getSignaturesOfType(d.target, SignatureKindCall), d.mapper) constructSignatures := c.instantiateSignatures(c.getSignaturesOfType(d.target, SignatureKindConstruct), d.mapper) indexInfos := c.instantiateIndexInfos(c.getIndexInfosOfType(d.target), d.mapper) - c.setStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos) + c.publishStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos) return } symbol := c.getMergedSymbol(t.symbol) if symbol.Flags()&ast.SymbolFlagsTypeLiteral != 0 { - c.setStructuredTypeMembers(t, nil, nil, nil, nil) + c.publishStructuredTypeMembers(t, nil, nil, nil, nil) members := c.getMembersOfSymbol(symbol) callSignatures := c.getSignaturesOfSymbol(members.Get(ast.InternalSymbolNameCall)) constructSignatures := c.getSignaturesOfSymbol(members.Get(ast.InternalSymbolNameNew)) indexInfos := c.getIndexInfosOfSymbol(symbol) - c.setStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos) + c.publishStructuredTypeMembers(t, members, callSignatures, constructSignatures, indexInfos) return } // Combinations of function, class, enum and module @@ -21379,7 +23605,7 @@ func (c *Checker) resolveAnonymousTypeMembers(t *Type) { baseConstructorIndexInfo = c.anyBaseTypeIndexInfo } } - c.setStructuredTypeMembers(t, members, nil, nil, nil) + c.publishStructuredTypeMembers(t, members, nil, nil, nil) var indexInfos []*IndexInfo if indexSymbol := members.Get(ast.InternalSymbolNameIndex); indexSymbol != nil { indexInfos = c.getIndexInfosOfIndexSymbol(indexSymbol, slices.Collect(members.Values())) @@ -21387,7 +23613,7 @@ func (c *Checker) resolveAnonymousTypeMembers(t *Type) { if baseConstructorIndexInfo != nil { indexInfos = append(indexInfos, baseConstructorIndexInfo) } - if symbol.Flags()&ast.SymbolFlagsEnum != 0 && (c.getDeclaredTypeOfSymbol(symbol).flags&TypeFlagsEnum != 0 || core.Some(d.getProperties(), func(prop *ast.Symbol) bool { + if symbol.Flags()&ast.SymbolFlagsEnum != 0 && (c.getDeclaredTypeOfSymbol(symbol).flags&TypeFlagsEnum != 0 || core.Some(d.getProperties(c), func(prop *ast.Symbol) bool { return c.getTypeOfSymbol(prop).flags&TypeFlagsNumberLike != 0 })) { indexInfos = append(indexInfos, c.enumNumberIndexInfo) @@ -21441,21 +23667,12 @@ func (c *Checker) instantiateSymbol(symbol *ast.Symbol, m *TypeMapper) *ast.Symb if m.MapsThisOnly() && isThisless(symbol) { return symbol } - // If the type of the symbol is already resolved, and if that type could not possibly - // be affected by instantiation, simply return the symbol itself. - if links.resolvedType != nil && !c.couldContainTypeVariables(links.resolvedType) { - if symbol.Flags()&ast.SymbolFlagsSetAccessor == 0 { - return symbol - } - // If we're a setter, check writeType. - if links.getWriteType() != nil && !c.couldContainTypeVariables(links.getWriteType()) { - return symbol - } - } + var instantiatedFrom *ast.Symbol if symbol.CheckFlags()&ast.CheckFlagsInstantiated != 0 { // If symbol being instantiated is itself a instantiation, fetch the original target and combine the // type mappers. This ensures that original type identities are properly preserved and that aliases // always reference a non-aliases. + instantiatedFrom = symbol symbol = links.target m = c.combineTypeMappers(links.mapper, m) } @@ -21466,6 +23683,7 @@ func (c *Checker) instantiateSymbol(symbol *ast.Symbol, m *TypeMapper) *ast.Symb resultLinks.target = symbol resultLinks.mapper = m resultLinks.setNameType(c, links.getNameType()) + resultLinks.setInstantiatedFrom(c, instantiatedFrom) return result } @@ -21558,7 +23776,7 @@ func (c *Checker) getDefaultConstructSignatures(classType *Type) []*Signature { sig = c.cloneSignature(baseSig) } sig.setTypeParameters(c, classType.AsInterfaceType().LocalTypeParameters()) - sig.resolvedReturnType = classType + sig.resolvedReturnType.intern(classType) if isAbstract { sig.flags |= SignatureFlagsAbstract } else { @@ -21574,7 +23792,7 @@ func (c *Checker) resolveMappedTypeMembers(t *Type) { members := ast.NewSymbolTable() var indexInfos []*IndexInfo // Resolve upfront such that recursive references see an empty object type. - c.setStructuredTypeMembers(t, nil, nil, nil, nil) + c.publishStructuredTypeMembers(t, nil, nil, nil, nil) // In { [P in K]: T }, we refer to P as the type parameter type, K as the constraint type, // and T as the template type. typeParameter := c.getTypeParameterFromMappedType(t) @@ -21657,15 +23875,24 @@ func (c *Checker) resolveMappedTypeMembers(t *Type) { } else { forEachType(c.getLowerBoundOfKeyType(constraintType), addMemberForKeyType) } - c.setStructuredTypeMembers(t, members, nil, nil, indexInfos) + c.publishStructuredTypeMembers(t, members, nil, nil, indexInfos) +} + +// mappedTypeContainsError reports whether the type of a property of the +// mapped type t circularly references itself. +func (c *Checker) mappedTypeContainsError(t *Type) bool { + for _, prop := range c.getPropertiesOfType(t) { + c.getTypeOfSymbol(prop) + } + return t.AsMappedType().containsError.cached(c) } func (c *Checker) getTypeOfMappedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { mappedType := links.getContainingType() - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { - mappedType.AsMappedType().containsError = true + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &links.resolvedType.memoHeader) { + mappedType.AsMappedType().containsError.setIdentity(c, true) return c.errorType } templateType := c.getTemplateTypeFromMappedType(core.OrElse(mappedType.AsMappedType().target, mappedType)) @@ -21681,17 +23908,17 @@ func (c *Checker) getTypeOfMappedSymbol(symbol *ast.Symbol) *Type { propType = c.removeMissingOrUndefinedType(propType) } if c.popTypeResolution() { - if links.resolvedType == nil { - links.resolvedType = propType + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, propType) } } else { - if links.resolvedType == nil { - links.resolvedType = c.errorType + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.errorType) } - c.error(c.currentNode, diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, c.symbolToString(symbol), c.TypeToString(mappedType)) + c.errorAtCurrentNode(diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, c.symbolToString(symbol), c.TypeToString(mappedType)) } } - return links.resolvedType + return links.resolvedType.cached(c) } // Return the lower bound of the key type in a mapped type. Intuitively, the lower @@ -21744,7 +23971,7 @@ func (c *Checker) resolveUnionTypeMembers(t *Type) { return c.getSignaturesOfType(t, SignatureKindConstruct) })) indexInfos := c.getUnionIndexInfos(t.Types()) - c.setStructuredTypeMembers(t, nil, callSignatures, constructSignatures, indexInfos) + c.setStructuredTypeData(t, nil, callSignatures, constructSignatures, indexInfos) } func (c *Checker) getArrayMemberCallSignatures(t *Type) []*Signature { @@ -21946,18 +24173,18 @@ func (c *Checker) combineUnionOrIntersectionParameters(left *Signature, right *S core.IfElse(isRestParam, ast.CheckFlagsRestParameter, core.IfElse(isOptional, ast.CheckFlagsOptionalParameter, 0))) links := c.valueSymbolLinks.Get(paramSymbol) if isRestParam { - links.resolvedType = c.createArrayType(combinedParamType) + links.resolvedType.setIdentity(c, c.createArrayType(combinedParamType)) } else { - links.resolvedType = combinedParamType + links.resolvedType.setIdentity(c, combinedParamType) } params[i] = paramSymbol } if needsExtraRestElement { restParamSymbol := c.newSymbolEx(ast.SymbolFlagsFunctionScopedVariable, "args", ast.CheckFlagsRestParameter) links := c.valueSymbolLinks.Get(restParamSymbol) - links.resolvedType = c.createArrayType(c.getTypeAtPosition(shorter, longestCount)) + links.resolvedType.setIdentity(c, c.createArrayType(c.getTypeAtPosition(shorter, longestCount))) if shorter == right { - links.resolvedType = c.instantiateType(links.resolvedType, mapper) + links.resolvedType.setIdentity(c, c.instantiateType(links.resolvedType.cached(c), mapper)) } params[longestCount] = restParamSymbol } @@ -21997,7 +24224,7 @@ func (c *Checker) resolveIntersectionTypeMembers(t *Type) { if len(signatures) != 0 && mixinCount > 0 { signatures = core.Map(signatures, func(s *Signature) *Signature { clone := c.cloneSignature(s) - clone.resolvedReturnType = c.includeMixinType(c.getReturnTypeOfSignature(s), types, mixinFlags, i) + clone.resolvedReturnType.intern(c.includeMixinType(c.getReturnTypeOfSignature(s), types, mixinFlags, i)) return clone }) } @@ -22008,7 +24235,7 @@ func (c *Checker) resolveIntersectionTypeMembers(t *Type) { indexInfos = c.appendIndexInfo(indexInfos, info, false /*union*/) } } - c.setStructuredTypeMembers(t, nil, callSignatures, constructSignatures, indexInfos) + c.setStructuredTypeData(t, nil, callSignatures, constructSignatures, indexInfos) } func (c *Checker) appendSignatures(signatures []*Signature, newSignatures []*Signature) []*Signature { @@ -22082,7 +24309,7 @@ func (c *Checker) includeMixinType(t *Type, types []*Type, mixinFlags []bool, in func (c *Checker) getPropertyOfObjectType(t *Type, name string) *ast.Symbol { if t.flags&TypeFlagsObject != 0 { resolved := c.resolveStructuredTypeMembers(t) - symbol := resolved.getMember(name) + symbol := resolved.getMember(c, name) if symbol != nil && c.symbolIsValue(symbol) { return symbol } @@ -22105,29 +24332,21 @@ func (c *Checker) getPropertyOfUnionOrIntersectionType(t *Type, name string, ski // these partial properties when identifying discriminant properties, but otherwise they are filtered out // and do not appear to be present in the union type. func (c *Checker) getUnionOrIntersectionProperty(t *Type, name string, skipObjectFunctionPropertyAugment bool) *ast.Symbol { - data := t.AsUnionOrIntersectionType() + d := t.AsUnionOrIntersectionType() + cache := &d.propertyCache if skipObjectFunctionPropertyAugment { - if prop := data.propertyCacheWithoutFunctionPropertyAugment.Get(name); prop != nil { - return prop - } - } else { - if prop := data.propertyCache.Get(name); prop != nil { - return prop - } - // Complete non-augmented properties are also valid for augmented - // lookup. Share the entry instead of retaining it in both tables. - if prop := data.propertyCacheWithoutFunctionPropertyAugment.Get(name); prop != nil && prop.CheckFlags()&ast.CheckFlagsPartial == 0 { - return prop - } + cache = &d.propertyCacheWithoutFunctionPropertyAugment + } + if prop, _ := cache.cached(c, name); prop != nil { + return prop } + // The property is created once, so its identity is kept. + cache.begin(c, name) prop := c.createUnionOrIntersectionProperty(t, name, skipObjectFunctionPropertyAugment) if prop != nil { - if skipObjectFunctionPropertyAugment { - ast.GetSymbolTable(&data.propertyCacheWithoutFunctionPropertyAugment).Set(name, prop) - } else { - ast.GetSymbolTable(&data.propertyCache).Set(name, prop) - } + cache.setIdentity(c, name, prop) } + c.endMemo() return prop } @@ -22272,7 +24491,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s var singlePropMapper *TypeMapper if singleProp.Flags()&ast.SymbolFlagsTransient != 0 { links := c.valueSymbolLinks.Get(singleProp) - singlePropType = links.resolvedType + singlePropType = links.resolvedType.cached(c) singlePropMapper = links.mapper } clone := c.createSymbolWithType(singleProp, singlePropType) @@ -22282,7 +24501,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s links := c.valueSymbolLinks.Get(clone) links.setContainingType(c, containingType) links.mapper = singlePropMapper - links.setWriteType(c, c.getWriteTypeOfSymbol(singleProp)) + links.setNewWriteType(c, c.getWriteTypeOfSymbol(singleProp)) return clone } if propSet.Size() == 0 { @@ -22348,15 +24567,15 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s return result } if isUnion { - links.resolvedType = c.getUnionType(propTypes) + links.resolvedType.setIdentity(c, c.getUnionType(propTypes)) } else { - links.resolvedType = c.getIntersectionType(propTypes) + links.resolvedType.setIdentity(c, c.getIntersectionType(propTypes)) } if writeTypes != nil { if isUnion { - links.setWriteType(c, c.getUnionType(writeTypes)) + links.setNewWriteType(c, c.getUnionType(writeTypes)) } else { - links.setWriteType(c, c.getIntersectionType(writeTypes)) + links.setNewWriteType(c, c.getIntersectionType(writeTypes)) } } return result @@ -22403,13 +24622,43 @@ func (c *Checker) hasCommonDeclaration(symbols *collections.OrderedSet[*ast.Symb return commonDeclarations.Len() != 0 } +type symbolWithTypeKey struct { + source *ast.Symbol + name string + t *Type +} + +// getSymbolWithType is createSymbolWithType for copies of object type members, +// returning the same copy for the same property and type. +func (c *Checker) getSymbolWithType(source *ast.Symbol, t *Type) *ast.Symbol { + key := symbolWithTypeKey{source: source, t: t} + if existing, _ := c.symbolsWithType.get(key); existing != nil { + return existing + } + result := c.createSymbolWithType(source, t) + c.symbolsWithType.intern(key, result) + return result +} + +// internObjectType returns an existing object type with the given content, or +// creates one with the given creation. +func (c *Checker) internObjectType(symbol *ast.Symbol, flags ObjectFlags, members ast.SymbolTable, indexInfos []*IndexInfo, create func() *Type) *Type { + key := c.getObjectTypeContentKey(symbol, flags&^(ObjectFlagsCouldContainTypeVariablesComputed|ObjectFlagsCouldContainTypeVariables|ObjectFlagsMembersResolved), members, indexInfos) + if existing, _ := c.objectContentTypes.get(key); existing != nil { + return existing + } + result := create() + c.objectContentTypes.intern(key, result) + return result +} + func (c *Checker) createSymbolWithType(source *ast.Symbol, t *Type) *ast.Symbol { symbol := c.newSymbolEx(source.Flags(), source.Name(), source.CheckFlags()&ast.CheckFlagsReadonly) symbol.SetDeclarations(source.Declarations()) symbol.SetParent(source.Parent()) symbol.SetValueDeclaration(source.ValueDeclaration()) links := c.valueSymbolLinks.Get(symbol) - links.resolvedType = t + links.resolvedType.setIdentity(c, t) links.target = source links.setNameType(c, c.valueSymbolLinks.Get(source).getNameType()) return symbol @@ -22466,10 +24715,7 @@ func (c *Checker) getApparentType(t *Type) *Type { func (c *Checker) getApparentTypeOfMappedType(t *Type) *Type { m := t.AsMappedType() - if m.resolvedApparentType == nil { - m.resolvedApparentType = c.getResolvedApparentTypeOfMappedType(t) - } - return m.resolvedApparentType + return c.memoCompute(&m.resolvedApparentType, func() *Type { return c.getResolvedApparentTypeOfMappedType(t) }) } func (c *Checker) getResolvedApparentTypeOfMappedType(t *Type) *Type { @@ -22499,16 +24745,17 @@ func (c *Checker) getResolvedApparentTypeOfMappedType(t *Type) *Type { func (c *Checker) getApparentTypeOfIntersectionType(t *Type, thisArgument *Type) *Type { if t == thisArgument { d := t.AsIntersectionType() - if d.resolvedApparentType == nil { - d.resolvedApparentType = c.getTypeWithThisArgument(t, thisArgument, true /*needApparentType*/) - } - return d.resolvedApparentType + return c.memoCompute(&d.resolvedApparentType, func() *Type { + return c.getTypeWithThisArgument(t, thisArgument, true /*needApparentType*/) + }) } key := CachedTypeKey{kind: CachedTypeKindApparentType, typeId: thisArgument.id} - result := c.cachedTypes[key] + result, _ := c.cachedTypes.cached(c, key) if result == nil { + c.cachedTypes.begin(c, key) result = c.getTypeWithThisArgument(t, thisArgument, true /*needApparentType*/) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() } return result } @@ -22523,27 +24770,29 @@ func (c *Checker) getReducedType(t *Type) *Type { switch { case t.flags&TypeFlagsUnion != 0: if t.objectFlags&ObjectFlagsContainsIntersections != 0 { - if reducedType := t.AsUnionType().resolvedReducedType; reducedType != nil { - return reducedType - } - reducedType := c.getReducedUnionType(t) - t.AsUnionType().resolvedReducedType = reducedType - return reducedType + return c.memoCompute(&t.AsUnionType().resolvedReducedType, func() *Type { return c.getReducedUnionType(t) }) } case t.flags&TypeFlagsIntersection != 0: - if t.objectFlags&ObjectFlagsIsNeverIntersectionComputed == 0 { - t.objectFlags |= ObjectFlagsIsNeverIntersectionComputed - if !c.isMappingOfSameObjectType(t.Types()) && c.somePropertyReducesToNever(t) { - t.objectFlags |= ObjectFlagsIsNeverIntersection - } - } - if t.objectFlags&ObjectFlagsIsNeverIntersection != 0 { + if c.isNeverIntersection(t) { return c.neverType } } return t } +// isNeverIntersection reports whether the intersection t reduces to never. +func (c *Checker) isNeverIntersection(t *Type) bool { + if c.objectFlagsKnown(t, ObjectFlagsIsNeverIntersectionComputed) { + return t.objectFlags&ObjectFlagsIsNeverIntersection != 0 + } + return c.objectFlagsCell(t, memoNeverIntersection, ObjectFlagsIsNeverIntersectionComputed, ObjectFlagsIsNeverIntersection, true /*inProgress*/, func() ObjectFlags { + if !c.isMappingOfSameObjectType(t.Types()) && c.somePropertyReducesToNever(t) { + return ObjectFlagsIsNeverIntersection + } + return 0 + }) != 0 +} + func (c *Checker) isMappingOfSameObjectType(types []*Type) bool { if len(types) != 0 && types[0].objectFlags&ObjectFlagsMapped != 0 { if firstType := c.getModifiersTypeFromMappedType(types[0]); firstType.flags&TypeFlagsObject != 0 { @@ -22592,7 +24841,7 @@ func (c *Checker) getReducedUnionType(unionType *Type) *Type { } reduced := c.getUnionType(reducedTypes) if reduced.flags&TypeFlagsUnion != 0 { - reduced.AsUnionType().resolvedReducedType = reduced + reduced.AsUnionType().resolvedReducedType.set(c, reduced) } return reduced } @@ -22610,7 +24859,7 @@ func (c *Checker) getReducedApparentType(t *Type) *Type { } func (c *Checker) elaborateNeverIntersection(chain *ast.Diagnostic, node *ast.Node, t *Type) *ast.Diagnostic { - if t.flags&TypeFlagsIntersection != 0 && t.objectFlags&ObjectFlagsIsNeverIntersection != 0 { + if t.flags&TypeFlagsIntersection != 0 && c.isNeverIntersection(t) { neverProp := core.Find(c.getPropertiesOfUnionOrIntersectionType(t), c.isDiscriminantWithNeverType) if neverProp != nil { return NewDiagnosticChainForNode(chain, node, diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents, c.typeToStringEx(t, nil, TypeFormatFlagsNoTypeReduction, nil), c.symbolToString(neverProp)) @@ -22636,42 +24885,56 @@ func isConflictingPrivateProperty(prop *ast.Symbol) bool { func (c *Checker) getTypeArguments(t *Type) []*Type { d := t.AsTypeReference() - if d.resolvedTypeArguments == nil { - n := d.target.AsInterfaceType() - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedTypeArguments) { - return slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters())) + if typeArguments := d.resolvedTypeArguments.cached(c); typeArguments != nil { + return typeArguments + } + d.resolvedTypeArguments.begin(c) + result := c.getTypeArgumentsUncached(t) + c.endMemo() + return result +} + +func (c *Checker) getTypeArgumentsUncached(t *Type) []*Type { + d := t.AsTypeReference() + n := d.target.AsInterfaceType() + if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedTypeArguments, &d.resolvedTypeArguments.memoHeader) { + return slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters())) + } + var typeArguments []*Type + node := t.AsTypeReference().node + if node != nil { + switch node.Kind { + case ast.KindTypeReference: + typeArguments = append(n.OuterTypeParameters(), c.getEffectiveTypeArguments(node, n.LocalTypeParameters())...) + case ast.KindArrayType: + typeArguments = []*Type{c.getTypeFromTypeNode(node.AsArrayTypeNode().ElementType)} + case ast.KindTupleType: + typeArguments = core.Map(node.Elements(), c.getTypeFromTypeNode) + default: + panic("Unhandled case in getTypeArguments") } - var typeArguments []*Type - node := t.AsTypeReference().node - if node != nil { - switch node.Kind { - case ast.KindTypeReference: - typeArguments = append(n.OuterTypeParameters(), c.getEffectiveTypeArguments(node, n.LocalTypeParameters())...) - case ast.KindArrayType: - typeArguments = []*Type{c.getTypeFromTypeNode(node.AsArrayTypeNode().ElementType)} - case ast.KindTupleType: - typeArguments = core.Map(node.Elements(), c.getTypeFromTypeNode) - default: - panic("Unhandled case in getTypeArguments") - } + } + if c.popTypeResolution() { + if d.resolvedTypeArguments.peek() == nil { + d.resolvedTypeArguments.set(c, c.instantiateTypes(typeArguments, d.mapper)) } - if c.popTypeResolution() { - if d.resolvedTypeArguments == nil { - d.resolvedTypeArguments = c.instantiateTypes(typeArguments, d.mapper) - } + } else { + if d.resolvedTypeArguments.peek() == nil { + d.resolvedTypeArguments.set(c, slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters()))) + } + message := diagnostics.Tuple_type_arguments_circularly_reference_themselves + var args []any + if d.target.symbol != nil { + message = diagnostics.Type_arguments_for_0_circularly_reference_themselves + args = []any{c.symbolToString(d.target.symbol)} + } + if node != nil { + c.error(node, message, args...) } else { - if d.resolvedTypeArguments == nil { - d.resolvedTypeArguments = slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters())) - } - errorNode := core.IfElse(node != nil, node, c.currentNode) - if d.target.symbol != nil { - c.error(errorNode, diagnostics.Type_arguments_for_0_circularly_reference_themselves, c.symbolToString(d.target.symbol)) - } else { - c.error(errorNode, diagnostics.Tuple_type_arguments_circularly_reference_themselves) - } + c.errorAtCurrentNode(message, args...) } } - return d.resolvedTypeArguments + return d.resolvedTypeArguments.peek() } func (c *Checker) getEffectiveTypeArguments(node *ast.Node, typeParameters []*Type) []*Type { @@ -22738,6 +25001,17 @@ func (c *Checker) getDefaultTypeArgumentType(isInJavaScriptFile bool) *Type { // this gets the instantiated default type of its target. If the type parameter has no default type or // the default is circular, `undefined` is returned. func (c *Checker) getDefaultFromTypeParameter(t *Type) *Type { + key := memoKeyOf(t, memoTypeParameterDefault) + if t.flags&TypeFlagsTypeParameter != 0 && t.AsTypeParameter().resolvedDefaultType.peek() != nil && c.readsWithoutMemo(key) { + return c.getDefaultFromTypeParameterUncached(t) + } + c.beginMemo(key) + result := c.getDefaultFromTypeParameterUncached(t) + c.endMemo() + return result +} + +func (c *Checker) getDefaultFromTypeParameterUncached(t *Type) *Type { if t.flags&TypeFlagsTypeParameter == 0 { return nil } @@ -22750,39 +25024,69 @@ func (c *Checker) getDefaultFromTypeParameter(t *Type) *Type { func (c *Checker) getResolvedTypeParameterDefault(t *Type) *Type { d := t.AsTypeParameter() - if d.resolvedDefaultType == nil { + if d.resolvedDefaultType.cached(c) == nil { if d.target != nil { targetDefault := c.getResolvedTypeParameterDefault(d.target) if targetDefault != nil { - d.resolvedDefaultType = c.instantiateType(targetDefault, d.mapper) + d.resolvedDefaultType.set(c, c.instantiateType(targetDefault, d.mapper)) } else { - d.resolvedDefaultType = c.noConstraintType + d.resolvedDefaultType.set(c, c.noConstraintType) } } else { - // To block recursion, set the initial value to the resolvingDefaultType. - d.resolvedDefaultType = c.resolvingDefaultType - defaultType := c.noConstraintType - if t.symbol != nil { - defaultDeclaration := core.FirstNonNil(t.symbol.Declarations(), func(decl *ast.Node) *ast.Node { - if ast.IsTypeParameterDeclaration(decl) { - return decl.AsTypeParameterDeclaration().DefaultType - } - return nil - }) - if defaultDeclaration != nil { - defaultType = c.getTypeFromTypeNode(defaultDeclaration) + c.resolveTypeParameterDefault(t) + } + } else if d.resolvedDefaultType.cached(c) == c.resolvingDefaultType { + // If we are called recursively for this type parameter, mark the default as circular. + c.observeCircularHead(t, TypeSystemPropertyNameDefaultType, c.compareTypeParameterDeclarations) + d.resolvedDefaultType.swap(c.circularConstraintType) + return c.circularConstraintType + } + return d.resolvedDefaultType.cached(c) +} + +// resolveTypeParameterDefault resolves the default of a declared type +// parameter. When defaults form a cycle, the first default resolved is the +// one found to be circular, so the default first in program order is always +// resolved first, discarding whatever was computed starting from another. +func (c *Checker) resolveTypeParameterDefault(t *Type) { + d := t.AsTypeParameter() + d.resolvedDefaultType.begin(c) + mark := c.markDiscard() + for { + // To block recursion, set the initial value to the resolvingDefaultType. + // Markers of a resolution in progress are never observed once it + // finishes, so they are not results to discard. + d.resolvedDefaultType.swap(c.resolvingDefaultType) + c.beginTypeResolution(t, TypeSystemPropertyNameDefaultType, nil) + defaultType := c.noConstraintType + if t.symbol != nil { + defaultDeclaration := core.FirstNonNil(t.symbol.Declarations(), func(decl *ast.Node) *ast.Node { + if ast.IsTypeParameterDeclaration(decl) { + return decl.AsTypeParameterDeclaration().DefaultType } - } - if d.resolvedDefaultType == c.resolvingDefaultType { - // If we have not been called recursively, set the correct default type. - d.resolvedDefaultType = defaultType + return nil + }) + if defaultDeclaration != nil { + defaultType = c.getTypeFromTypeNode(defaultDeclaration) } } - } else if d.resolvedDefaultType == c.resolvingDefaultType { - // If we are called recursively for this type parameter, mark the default as circular. - d.resolvedDefaultType = c.circularConstraintType + if d.resolvedDefaultType.swap(nil) != c.resolvingDefaultType { + // We were called recursively, so the default is circular. + defaultType = c.circularConstraintType + } + canonical := c.popCircularHead(mark) + if canonical == nil { + d.resolvedDefaultType.set(c, defaultType) + break + } + c.getResolvedTypeParameterDefault(canonical.(*Type)) } - return d.resolvedDefaultType + c.releaseDiscardMark(mark) + c.endMemo() +} + +func (c *Checker) compareTypeParameterDeclarations(a, b TypeSystemEntity) int { + return c.compareSymbols(a.(*Type).symbol, b.(*Type).symbol) } func (c *Checker) getDefaultOrUnknownFromTypeParameter(t *Type) *Type { @@ -22828,21 +25132,37 @@ func (c *Checker) instantiateTypeWithAlias(t *Type, m *TypeMapper, alias *TypeAl if t == nil || m == nil || !(c.couldContainTypeVariables(t) || (t.alias != nil && len(t.alias.typeArguments) > 0 && core.Some(t.alias.typeArguments, c.couldContainTypeVariables))) { return t } - if len(c.instantiationStack) == 100 || c.instantiationCount >= 5_000_000 { - // We have reached 100 recursive type instantiations, or 5M type instantiations caused by the same statement - // or expression. There is a very high likelihood we're dealing with a combination of infinite generic types + // See "Instantiation limits" in memo.go. + if len(c.instantiationStack) == instantiationStackLimit || c.instantiationAborted { + c.abortInstantiation() + return c.errorType + } + depthLimitReached := c.instantiationDepthLimitReached() + if depthLimitReached || c.instantiationCount >= instantiationCountLimit { + // We have reached 100 recursive type instantiations in one computation, or 5M type instantiations caused by + // the same statement or expression. There is a very high likelihood we're dealing with a combination of infinite generic types // that perpetually generate new type identities, so we stop the recursion here by yielding the error type. if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "instantiateType_DepthLimit", map[string]any{"typeId": t.id, "instantiationDepth": len(c.instantiationStack), "instantiationCount": c.instantiationCount}) } circularTypeNames := c.getCircularTypeNames() + var message *diagnostics.Message + var args []any switch { case len(circularTypeNames) == 1: - c.error(c.currentNode, diagnostics.Instantiations_of_type_0_appear_infinitely_circular, circularTypeNames[0]) + message, args = diagnostics.Instantiations_of_type_0_appear_infinitely_circular, []any{circularTypeNames[0]} case len(circularTypeNames) > 1: - c.error(c.currentNode, diagnostics.Instantiations_of_the_following_types_appear_infinitely_circular_Colon_0, quotedAndCommaSeparated(circularTypeNames)) + message, args = diagnostics.Instantiations_of_the_following_types_appear_infinitely_circular_Colon_0, []any{quotedAndCommaSeparated(circularTypeNames)} default: - c.error(c.currentNode, diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) + message = diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite + } + report := func(c *Checker, node *ast.Node) { c.error(node, message, args...) } + if depthLimitReached { + c.reportAtCurrentNode(report) + } else { + // The count depends on how much was already cached, so computing + // the result again elsewhere would not reliably reach it either. + c.reportAtCurrentNodeOnce(report) } return c.errorType } @@ -22853,8 +25173,11 @@ func (c *Checker) instantiateTypeWithAlias(t *Type, m *TypeMapper, alias *TypeAl c.pushActiveMapper(m) } else { key = getActiveMapperCacheKey(t, alias) - if cachedType, ok := c.activeTypeMappersCaches[index].get(key); ok { - return cachedType + // An instantiation cached in another resolution was computed against that + // resolution's depth limit, so it is only reused within the same + // resolution. + if cached, ok := c.activeTypeMappersCaches[index].get(key); ok && cached.serial == c.currentResolution().serial { + return cached.result } } c.TotalInstantiationCount++ @@ -22864,13 +25187,22 @@ func (c *Checker) instantiateTypeWithAlias(t *Type, m *TypeMapper, alias *TypeAl if index == -1 { c.popActiveMapper() } else { - c.activeTypeMappersCaches[index].set(key, result) + c.activeTypeMappersCaches[index].set(key, activeMapperCacheEntry{result, c.currentResolution().serial}) } c.instantiationStack[len(c.instantiationStack)-1] = nil c.instantiationStack = c.instantiationStack[:len(c.instantiationStack)-1] + if c.instantiationAborted && len(c.instantiationStack) == c.instantiationAbortRoot { + c.endInstantiationAbort() + return c.errorType + } return result } +type activeMapperCacheEntry struct { + result *Type + serial uint32 +} + // Without an alias the key is just the type ID, which avoids hashing. Hashed keys have // a nonzero high half with overwhelming probability, so the two kinds do not collide. func getActiveMapperCacheKey(t *Type, alias *TypeAlias) CacheHashKey { @@ -22885,21 +25217,28 @@ func getActiveMapperCacheKey(t *Type, alias *TypeAlias) CacheHashKey { func (c *Checker) getCircularTypeNames() []string { typeCounts := make(map[*Type]int) - var circularTypeNames []string - for _, t := range c.instantiationStack { + var circularSymbols []*ast.Symbol + // A computation reaching the depth limit names only its own + // instantiations, which do not depend on where it was first computed; + // see "Instantiation limits". + for _, t := range c.instantiationStack[c.currentResolution().depthStart:] { typeCounts[t] = typeCounts[t] + 1 if typeCounts[t] == 3 { symbol := t.symbol if t.alias != nil { symbol = t.alias.symbol } - if symbol != nil && len(symbol.Name()) != 0 && symbol.Name()[0] != '\xFE' { - if name := c.SymbolToString(symbol); !slices.Contains(circularTypeNames, name) { - circularTypeNames = append(circularTypeNames, name) - } + if symbol != nil && len(symbol.Name()) != 0 && symbol.Name()[0] != '\xFE' && !slices.Contains(circularSymbols, symbol) { + circularSymbols = append(circularSymbols, symbol) } } } + var circularTypeNames []string + for _, s := range circularSymbols { + if name := c.SymbolToString(s); !slices.Contains(circularTypeNames, name) { + circularTypeNames = append(circularTypeNames, name) + } + } return circularTypeNames } @@ -22911,7 +25250,7 @@ func (c *Checker) pushActiveMapper(mapper *TypeMapper) { // The cap may contain an empty cache from popActiveMapper; reuse it. c.activeTypeMappersCaches = c.activeTypeMappersCaches[:lastIndex+1] } else { - c.activeTypeMappersCaches = append(c.activeTypeMappersCaches, clearableMap[*Type]{}) + c.activeTypeMappersCaches = append(c.activeTypeMappersCaches, clearableMap[activeMapperCacheEntry]{}) } } @@ -22942,16 +25281,21 @@ func (c *Checker) couldContainTypeVariablesWorker(t *Type) bool { if t.flags&TypeFlagsStructuredOrInstantiable == 0 { return false } - objectFlags := t.objectFlags - if objectFlags&ObjectFlagsCouldContainTypeVariablesComputed != 0 { - return objectFlags&ObjectFlagsCouldContainTypeVariables != 0 + if c.objectFlagsKnown(t, ObjectFlagsCouldContainTypeVariablesComputed) { + return t.objectFlags&ObjectFlagsCouldContainTypeVariables != 0 } + return c.objectFlagsCell(t, memoCouldContainTypeVariables, ObjectFlagsCouldContainTypeVariablesComputed, ObjectFlagsCouldContainTypeVariables, false /*inProgress*/, func() ObjectFlags { + return core.IfElse(c.computeCouldContainTypeVariables(t), ObjectFlagsCouldContainTypeVariables, 0) + }) != 0 +} + +func (c *Checker) computeCouldContainTypeVariables(t *Type) bool { + objectFlags := t.objectFlags result := t.flags&TypeFlagsInstantiable != 0 || t.flags&TypeFlagsObject != 0 && !c.isNonGenericTopLevelType(t) && (objectFlags&ObjectFlagsReference != 0 && (t.AsTypeReference().node != nil || core.Some(c.getTypeArguments(t), c.couldContainTypeVariables)) || objectFlags&ObjectFlagsAnonymous != 0 && t.symbol != nil && t.symbol.Flags()&(ast.SymbolFlagsFunction|ast.SymbolFlagsMethod|ast.SymbolFlagsClass|ast.SymbolFlagsTypeLiteral|ast.SymbolFlagsObjectLiteral) != 0 && t.symbol.Declarations() != nil && !isModuleWrapperSymbol(t.symbol) || objectFlags&(ObjectFlagsMapped|ObjectFlagsReverseMapped|ObjectFlagsObjectRestType|ObjectFlagsInstantiationExpressionType) != 0) || t.flags&TypeFlagsUnionOrIntersection != 0 && t.flags&TypeFlagsEnumLiteral == 0 && !c.isNonGenericTopLevelType(t) && core.Some(t.Types(), c.couldContainTypeVariables) - t.objectFlags |= ObjectFlagsCouldContainTypeVariablesComputed | core.IfElse(result, ObjectFlagsCouldContainTypeVariables, 0) return result } @@ -22983,7 +25327,7 @@ func (c *Checker) instantiateTypeWorker(t *Type, m *TypeMapper, alias *TypeAlias objectFlags := t.objectFlags if objectFlags&(ObjectFlagsReference|ObjectFlagsAnonymous|ObjectFlagsMapped) != 0 { if objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == nil { - resolvedTypeArguments := t.AsTypeReference().resolvedTypeArguments + resolvedTypeArguments := t.AsTypeReference().typeArgumentsOfCreation() newTypeArguments := c.instantiateTypes(resolvedTypeArguments, m) if core.Same(newTypeArguments, resolvedTypeArguments) { return t @@ -23038,16 +25382,15 @@ func (c *Checker) instantiateTypeWorker(t *Type, m *TypeMapper, alias *TypeAlias newConstraint := c.instantiateType(t.AsSubstitutionType().constraint, m) // A substitution type originates in the true branch of a conditional type and can be resolved // to just the base type in the same cases as the conditional type resolves to its true branch - // (because the base type is then known to satisfy the constraint). - if newBaseType.flags&TypeFlagsTypeVariable != 0 && c.isGenericType(newConstraint) { + // (because the base type is then known to satisfy the constraint). A conditional type whose + // check type is a type variable is deferred instead, so a substitution for a type variable is + // kept. + if newBaseType.flags&TypeFlagsTypeVariable != 0 { return c.getSubstitutionType(newBaseType, newConstraint) } if newConstraint.flags&TypeFlagsAnyOrUnknown != 0 || c.isTypeAssignableTo(c.getRestrictiveInstantiation(newBaseType), c.getRestrictiveInstantiation(newConstraint)) { return newBaseType } - if newBaseType.flags&TypeFlagsTypeVariable != 0 { - return c.getSubstitutionType(newBaseType, newConstraint) - } return c.getIntersectionType([]*Type{newConstraint, newBaseType}) } return t @@ -23073,14 +25416,15 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type links := c.typeNodeLinks.Get(declaration) switch { case t.objectFlags&ObjectFlagsReference != 0: // Deferred type reference - target = links.resolvedType + target = c.getTypeFromTypeNodeWorker(declaration) case t.objectFlags&ObjectFlagsInstantiated != 0: target = t.Target() default: target = t } - typeParameters = links.getOuterTypeParameters() + typeParameters = links.cachedOuterTypeParameters(c) if typeParameters == nil { + links.outerTypeParameters.begin(c) // The first time an anonymous type is instantiated we compute and store a list of the type // parameters that are in scope (and therefore potentially referenced). For type literals that // aren't the right hand side of a generic type alias declaration we optimize by reducing the @@ -23103,6 +25447,7 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type typeParameters = []*Type{} } links.setOuterTypeParameters(c, typeParameters) + c.endMemo() } if len(typeParameters) == 0 { return t @@ -23118,38 +25463,58 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type if newAlias == nil { newAlias = c.instantiateTypeAlias(t.alias, m) } + instantiate := func(newMapper *TypeMapper) *Type { + switch { + case target.objectFlags&ObjectFlagsReference != 0: + return c.createDeferredTypeReference(t.Target(), t.AsTypeReference().node, newMapper, newAlias) + case target.objectFlags&ObjectFlagsMapped != 0: + return c.instantiateMappedType(target, newMapper, newAlias) + default: + return c.instantiateAnonymousType(target, newMapper, newAlias) + } + } + if target.objectFlags&ObjectFlagsSingleSignatureType != 0 && m != nil { + // The signature may reference type parameters other than the outer + // type parameters of its declaration, so the instantiation is not + // determined by the type arguments and cannot be cached by them. + return instantiate(c.combineTypeMappers(newTypeMapper(typeParameters, typeArguments), m)) + } data := target.AsObjectType() key := getTypeInstantiationKey(typeArguments, newAlias, t.objectFlags&ObjectFlagsSingleSignatureType != 0) - if data.instantiations == nil { - data.instantiations = make(map[CacheHashKey]*Type) - data.instantiations[getTypeInstantiationKey(typeParameters, target.alias, false)] = target + if data.instantiations.isEmpty() { + data.instantiations.intern(getTypeInstantiationKey(typeParameters, target.alias, false), target) } - result := data.instantiations[key] + result, _ := data.instantiations.cached(c, key) if result == nil { - newMapper := newTypeMapper(typeParameters, typeArguments) - if target.objectFlags&ObjectFlagsSingleSignatureType != 0 && m != nil { - newMapper = c.combineTypeMappers(newMapper, m) + reports := c.startCurrentNodeErrors() + data.instantiations.begin(c, key) + if c.beginInstantiation() { + result = c.errorType + } else { + result = instantiate(newTypeMapper(typeParameters, typeArguments)) } - switch { - case target.objectFlags&ObjectFlagsReference != 0: - result = c.createDeferredTypeReference(t.Target(), t.AsTypeReference().node, newMapper, newAlias) - case target.objectFlags&ObjectFlagsMapped != 0: - result = c.instantiateMappedType(target, newMapper, newAlias) - default: - result = c.instantiateAnonymousType(target, newMapper, newAlias) + if !c.endInstantiation(reports) { + return c.errorType } - data.instantiations[key] = result + data.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) + c.endMemo() if result.flags&TypeFlagsObjectFlagsType != 0 && result.objectFlags&ObjectFlagsCouldContainTypeVariablesComputed == 0 { // if `result` is one of the object types we tried to make (it may not be, due to how `instantiateMappedType` works), we can carry forward the type variable containment check from the input type arguments resultCouldContainObjectFlags := core.Some(typeArguments, c.couldContainTypeVariables) if result.objectFlags&ObjectFlagsCouldContainTypeVariablesComputed == 0 { + // The flags are part of creating the type, so they are kept for + // as long as the type is, even if created in a cycle that is + // discarded; computed again from the structure of the type, they + // may differ. if result.objectFlags&(ObjectFlagsMapped|ObjectFlagsAnonymous|ObjectFlagsReference) != 0 { result.objectFlags |= ObjectFlagsCouldContainTypeVariablesComputed | core.IfElse(resultCouldContainObjectFlags, ObjectFlagsCouldContainTypeVariables, 0) - } else { + c.setFlagMemo(memoKeyOf(result, memoCouldContainTypeVariables)) + } else if !resultCouldContainObjectFlags { // If none of the type arguments for the outer type parameters contain type variables, it follows // that the instantiated type doesn't reference type variables. // Intrinsics have `CouldContainTypeVariablesComputed` pre-set, so this should only cover unions and intersections resulting from `instantiateMappedType` - result.objectFlags |= core.IfElse(!resultCouldContainObjectFlags, ObjectFlagsCouldContainTypeVariablesComputed, 0) + result.objectFlags |= ObjectFlagsCouldContainTypeVariablesComputed + c.setFlagMemo(memoKeyOf(result, memoCouldContainTypeVariables)) } } } @@ -23220,7 +25585,7 @@ func (c *Checker) instantiateAnonymousType(t *Type, m *TypeMapper, alias *TypeAl // C.f. instantiateSignature origTypeParameter := c.getTypeParameterFromMappedType(t) freshTypeParameter := c.cloneTypeParameter(origTypeParameter) - result.AsMappedType().typeParameter = freshTypeParameter + result.AsMappedType().typeParameter.intern(freshTypeParameter) m = c.combineTypeMappers(newSimpleTypeMapper(origTypeParameter, freshTypeParameter), m) freshTypeParameter.AsTypeParameter().mapper = m case t.objectFlags&ObjectFlagsInstantiationExpressionType != 0: @@ -23247,8 +25612,15 @@ func (c *Checker) getConditionalTypeInstantiation(t *Type, mapper *TypeMapper, f // instantiation cache key from the type IDs of the type arguments. typeArguments := core.Map(root.outerTypeParameters, mapper.Map) key := getConditionalTypeKey(typeArguments, alias, forConstraint) - result := root.instantiations[key] + result, _ := root.instantiations.cached(c, key) if result == nil { + reports := c.startCurrentNodeErrors() + root.instantiations.begin(c, key) + if c.beginInstantiation() { + root.instantiations.setReported(c, key, c.errorType, c.endCurrentNodeErrors(reports)) + c.endMemo() + return c.errorType + } newMapper := newTypeMapper(root.outerTypeParameters, typeArguments) checkType := root.checkType var distributionType *Type @@ -23265,7 +25637,11 @@ func (c *Checker) getConditionalTypeInstantiation(t *Type, mapper *TypeMapper, f } else { result = c.getConditionalType(root, newMapper, forConstraint, alias) } - root.instantiations[key] = result + if !c.endInstantiation(reports) { + return c.errorType + } + root.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) + c.endMemo() } return result } @@ -23309,7 +25685,7 @@ func (c *Checker) instantiateMappedType(t *Type, m *TypeMapper, alias *TypeAlias return s } if d.declaration.NameType == nil { - if c.isArrayType(s) || s.flags&TypeFlagsAny != 0 && c.findResolutionCycleStartIndex(typeVariable, TypeSystemPropertyNameResolvedBaseConstraint) < 0 && c.hasArrayOrTypeTypeConstraint(typeVariable) { + if c.isArrayType(s) || s.flags&TypeFlagsAny != 0 && !c.isBaseConstraintInProgress(typeVariable) && c.hasArrayOrTypeTypeConstraint(typeVariable) { return c.instantiateMappedArrayType(s, t, prependTypeMapping(typeVariable, s, m)) } if isTupleType(s) { @@ -23426,18 +25802,16 @@ func getModifiedReadonlyState(state bool, modifiers MappedTypeModifiers) bool { func (c *Checker) getTypeParameterFromMappedType(t *Type) *Type { m := t.AsMappedType() - if m.typeParameter == nil { - m.typeParameter = c.getDeclaredTypeOfTypeParameter(c.getSymbolOfDeclaration(m.declaration.TypeParameter)) - } - return m.typeParameter + return c.memoCompute(&m.typeParameter, func() *Type { + return c.getDeclaredTypeOfTypeParameter(c.getSymbolOfDeclaration(m.declaration.TypeParameter)) + }) } func (c *Checker) getConstraintTypeFromMappedType(t *Type) *Type { m := t.AsMappedType() - if m.constraintType == nil { - m.constraintType = core.OrElse(c.getConstraintOfTypeParameter(c.getTypeParameterFromMappedType(t)), c.errorType) - } - return m.constraintType + return c.memoCompute(&m.constraintType, func() *Type { + return core.OrElse(c.getConstraintOfTypeParameter(c.getTypeParameterFromMappedType(t)), c.errorType) + }) } func (c *Checker) getNameTypeFromMappedType(t *Type) *Type { @@ -23445,22 +25819,19 @@ func (c *Checker) getNameTypeFromMappedType(t *Type) *Type { if m.declaration.NameType == nil { return nil } - if m.nameType == nil { - m.nameType = c.instantiateType(c.getTypeFromTypeNode(m.declaration.NameType), m.mapper) - } - return m.nameType + return c.memoCompute(&m.nameType, func() *Type { + return c.instantiateType(c.getTypeFromTypeNode(m.declaration.NameType), m.mapper) + }) } func (c *Checker) getTemplateTypeFromMappedType(t *Type) *Type { m := t.AsMappedType() - if m.templateType == nil { + return c.memoCompute(&m.templateType, func() *Type { if m.declaration.Type != nil { - m.templateType = c.instantiateType(c.addOptionalityEx(c.getTypeFromTypeNode(m.declaration.Type) /*isProperty*/, true, getMappedTypeModifiers(t)&MappedTypeModifiersIncludeOptional != 0), m.mapper) - } else { - m.templateType = c.errorType + return c.instantiateType(c.addOptionalityEx(c.getTypeFromTypeNode(m.declaration.Type) /*isProperty*/, true, getMappedTypeModifiers(t)&MappedTypeModifiersIncludeOptional != 0), m.mapper) } - } - return m.templateType + return c.errorType + }) } func (c *Checker) isMappedTypeWithKeyofConstraintDeclaration(t *Type) bool { @@ -23561,27 +25932,60 @@ func (c *Checker) tryGetTypeFromTypeNode(node *ast.Node) *Type { return nil } -func (c *Checker) getTypeFromTypeNode(node *ast.Node) *Type { - return c.getConditionalFlowTypeOfType(c.getTypeFromTypeNodeWorker(node), node) +func (c *Checker) getTypeFromTypeNode(node *ast.Node) *Type { + if t := c.getKeywordTypeOfTypeNode(node); t != nil && !isConditionalFlowTypeLocation(node) { + // A keyword type is the same everywhere getConditionalFlowTypeOfType + // leaves it unchanged, and computing it has no effects. + return t + } + key := memoKeyOf(node, memoTypeNodeType) + // The kinds whose type is cached in the node's links can read it, at a + // location where getConditionalFlowTypeOfType leaves it unchanged. + switch node.Kind { + case ast.KindTypeReference, ast.KindExpressionWithTypeArguments, ast.KindUnionType, ast.KindIntersectionType, + ast.KindConditionalType, ast.KindIndexedAccessType, ast.KindArrayType, ast.KindTupleType, ast.KindThisType, + ast.KindTypeOperator, ast.KindLiteralType: + if links := c.typeNodeLinks.TryGet(node); links != nil { + if t := links.resolvedType.peek(); t != nil && !isConditionalFlowTypeLocation(node) && c.readsWithoutMemo(key) { + return t + } + } + } + c.beginMemo(key) + result := c.getTypeFromTypeNodeUncached(node) + c.endMemo() + return result +} + +// memoTypeNode calls a getTypeFromXXXNode worker that caches its result in the +// links of the type node. +func memoTypeNode(c *Checker, node *ast.Node, worker func(*Checker, *ast.Node) *Type) *Type { + c.typeNodeLinks.Get(node).resolvedType.begin(c) + result := worker(c, node) + c.endMemo() + return result } -func (c *Checker) getTypeFromTypeNodeWorker(node *ast.Node) *Type { +// isConditionalFlowTypeLocation reports whether getConditionalFlowTypeOfType +// may change the type of node: whether it is within the true branch of a +// conditional type, or the template of a mapped type without an as clause. +func isConditionalFlowTypeLocation(node *ast.Node) bool { + for n := node; n != nil && !ast.IsStatement(n) && n.Kind != ast.KindJSDoc; n = n.Parent { + parent := n.Parent + if ast.IsConditionalTypeNode(parent) && n == parent.AsConditionalTypeNode().TrueType || + ast.IsMappedTypeNode(parent) && parent.AsMappedTypeNode().NameType == nil && n == parent.Type() { + return true + } + } + return false +} + +// getKeywordTypeOfTypeNode returns the type of a keyword type node, or nil if +// node is not one. +func (c *Checker) getKeywordTypeOfTypeNode(node *ast.Node) *Type { switch node.Kind { case ast.KindAnyKeyword, ast.KindJSDocAllType: return c.anyType - case ast.KindJSDocNonNullableType: - return c.getTypeFromTypeNode(node.Type()) - case ast.KindJSDocNullableType: - t := c.getTypeFromTypeNode(node.Type()) - if c.strictNullChecks { - return c.getNullableType(t, TypeFlagsNull) - } else { - return t - } - case ast.KindJSDocVariadicType: - return c.createArrayType(c.getTypeFromTypeNode(node.AsJSDocVariadicType().Type)) - case ast.KindJSDocOptionalType: - return c.addOptionality(c.getTypeFromTypeNode(node.Type())) case ast.KindUnknownKeyword: return c.unknownType case ast.KindStringKeyword: @@ -23606,6 +26010,32 @@ func (c *Checker) getTypeFromTypeNodeWorker(node *ast.Node) *Type { return c.nonPrimitiveType case ast.KindIntrinsicKeyword: return c.intrinsicMarkerType + } + return nil +} + +func (c *Checker) getTypeFromTypeNodeUncached(node *ast.Node) *Type { + return c.getConditionalFlowTypeOfType(c.getTypeFromTypeNodeWorker(node), node) +} + +func (c *Checker) getTypeFromTypeNodeWorker(node *ast.Node) *Type { + if t := c.getKeywordTypeOfTypeNode(node); t != nil { + return t + } + switch node.Kind { + case ast.KindJSDocNonNullableType: + return c.getTypeFromTypeNode(node.Type()) + case ast.KindJSDocNullableType: + t := c.getTypeFromTypeNode(node.Type()) + if c.strictNullChecks { + return c.getNullableType(t, TypeFlagsNull) + } else { + return t + } + case ast.KindJSDocVariadicType: + return c.createArrayType(c.getTypeFromTypeNode(node.AsJSDocVariadicType().Type)) + case ast.KindJSDocOptionalType: + return c.addOptionality(c.getTypeFromTypeNode(node.Type())) case ast.KindThisType, ast.KindThisKeyword: return c.getTypeFromThisTypeNode(node) case ast.KindLiteralType: @@ -23656,10 +26086,10 @@ func (c *Checker) getTypeFromTypeNodeWorker(node *ast.Node) *Type { func (c *Checker) getTypeFromThisTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.getThisType(node) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getThisType(node)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getThisType(node *ast.Node) *Type { @@ -23681,66 +26111,66 @@ func (c *Checker) getTypeFromLiteralTypeNode(node *ast.Node) *Type { return c.nullType } links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.getRegularTypeOfLiteralType(c.checkExpression(node.AsLiteralTypeNode().Literal)) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getRegularTypeOfLiteralType(c.checkExpression(node.AsLiteralTypeNode().Literal))) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { // Deferred resolution of members is handled by resolveObjectTypeMembers alias := c.getAliasForTypeNode(node) if sym := node.Symbol(); sym == nil || c.getMembersOfSymbol(sym).Len() == 0 && alias == nil { - links.resolvedType = c.emptyTypeLiteralType + links.resolvedType.set(c, c.emptyTypeLiteralType) } else { t := c.newObjectType(ObjectFlagsAnonymous, node.Symbol()) t.alias = alias - links.resolvedType = t + links.resolvedType.set(c, t) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromIndexedAccessTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { objectType := c.getTypeFromTypeNode(node.AsIndexedAccessTypeNode().ObjectType) indexType := c.getTypeFromTypeNode(node.AsIndexedAccessTypeNode().IndexType) potentialAlias := c.getAliasForTypeNode(node) - links.resolvedType = c.getIndexedAccessTypeEx(objectType, indexType, AccessFlagsNone, node, potentialAlias) + links.resolvedType.set(c, c.getIndexedAccessTypeEx(objectType, indexType, AccessFlagsNone, node, potentialAlias)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromTypeOperatorNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { argType := node.Type() switch node.AsTypeOperatorNode().Operator { case ast.KindKeyOfKeyword: - links.resolvedType = c.getIndexType(c.getTypeFromTypeNode(argType)) + links.resolvedType.set(c, c.getIndexType(c.getTypeFromTypeNode(argType))) case ast.KindUniqueKeyword: if argType.Kind == ast.KindSymbolKeyword { - links.resolvedType = c.getESSymbolLikeTypeForNode(ast.WalkUpParenthesizedTypes(node.Parent)) + links.resolvedType.set(c, c.getESSymbolLikeTypeForNode(ast.WalkUpParenthesizedTypes(node.Parent))) } else { - links.resolvedType = c.errorType + links.resolvedType.set(c, c.errorType) } case ast.KindReadonlyKeyword: - links.resolvedType = c.getTypeFromTypeNode(argType) + links.resolvedType.set(c, c.getTypeFromTypeNode(argType)) default: panic("Unhandled case in getTypeFromTypeOperatorNode") } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getESSymbolLikeTypeForNode(node *ast.Node) *Type { if isValidESSymbolDeclaration(node) { symbol := c.getSymbolOfNode(node) if symbol != nil { - uniqueType := c.uniqueESSymbolTypes[symbol] + uniqueType, _ := c.uniqueESSymbolTypes.get(symbol) if uniqueType == nil { var b strings.Builder b.WriteString(ast.InternalSymbolNamePrefix) @@ -23749,7 +26179,7 @@ func (c *Checker) getESSymbolLikeTypeForNode(node *ast.Node) *Type { b.WriteByte('@') b.WriteString(strconv.FormatUint(uint64(ast.GetSymbolId(symbol)), 10)) uniqueType = c.newUniqueESSymbolType(symbol, b.String()) - c.uniqueESSymbolTypes[symbol] = uniqueType + c.uniqueESSymbolTypes.intern(symbol, uniqueType) } return uniqueType } @@ -23759,19 +26189,25 @@ func (c *Checker) getESSymbolLikeTypeForNode(node *ast.Node) *Type { func (c *Checker) getTypeFromTypeReference(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { // Cache both the resolved symbol and the resolved type. The resolved symbol is needed when we check the // type reference in checkTypeReferenceNode. // handle LS queries on the `const` in `x as const` by resolving to the type of `x` if isConstTypeReference(node) && ast.IsAssertionExpression(node.Parent) { - links.resolvedType = c.checkExpressionCached(node.Parent.Expression()) + links.resolvedType.set(c, c.checkExpressionCached(node.Parent.Expression())) } else if t := c.getIntendedTypeFromJSDocTypeReference(node); t != nil { - links.resolvedType = t + links.resolvedType.set(c, t) } else { - links.resolvedType = c.getDistributedTypeParameter(node, c.getTypeReferenceType(node, c.getSymbolFromTypeReference(node))) + t := c.getDistributedTypeParameter(node, c.getTypeReferenceType(node, c.getSymbolFromTypeReference(node))) + if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == node { + // A deferred reference is identified by the node, so it outlives a cycle. + links.resolvedType.setIdentity(c, t) + } else { + links.resolvedType.set(c, t) + } } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getDistributedTypeParameter(node *ast.Node, t *Type) *Type { @@ -23793,15 +26229,17 @@ func (c *Checker) getDistributedTypeFromTypeParameter(t *Type) *Type { tp := t.AsTypeParameter() if tp.distributedType == nil { tp.distributedType = c.newTypeParameter(t.symbol) - tp.distributedType.AsTypeParameter().isDistributed = true - tp.distributedType.AsTypeParameter().constraint = t + distributed := tp.distributedType.AsTypeParameter() + distributed.isDistributed = true + distributed.constraint.intern(t) + distributed.distributedType = t } return tp.distributedType } func getNonDistributedTypeParameter(t *Type) *Type { if t.flags&TypeFlagsTypeParameter != 0 && t.AsTypeParameter().isDistributed { - return t.AsTypeParameter().constraint + return t.AsTypeParameter().distributedType } return t } @@ -23868,13 +26306,20 @@ func (c *Checker) getIntendedTypeFromJSDocTypeReference(node *ast.Node) *Type { } func (c *Checker) getSymbolFromTypeReference(node *ast.Node) *ast.Symbol { + c.symbolNodeLinks.Get(node).resolvedSymbol.begin(c) + result := c.getSymbolFromTypeReferenceCached(node) + c.endMemo() + return result +} + +func (c *Checker) getSymbolFromTypeReferenceCached(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol == nil { + if links.resolvedSymbol.cached(c) == nil { // The `const` in a `const` assertion resolves to nothing; resolveName knows not to // report an error for it, so no special-casing is needed here. - links.resolvedSymbol = c.resolveTypeReferenceName(node, ast.SymbolFlagsType, false /*ignoreErrors*/) + links.resolvedSymbol.set(c, c.resolveTypeReferenceName(node, ast.SymbolFlagsType, false /*ignoreErrors*/)) } - return links.resolvedSymbol + return links.resolvedSymbol.cached(c) } func (c *Checker) resolveTypeReferenceName(typeReference *ast.Node, meaning ast.SymbolFlags, ignoreErrors bool) *ast.Symbol { @@ -23917,12 +26362,12 @@ func (c *Checker) getUnresolvedSymbolForEntityName(name *ast.Node) *ast.Symbol { } else { path = text } - result := c.unresolvedSymbols[path] + result, _ := c.unresolvedSymbols.get(path) if result == nil { result = c.newSymbolEx(ast.SymbolFlagsTypeAlias, text, ast.CheckFlagsUnresolved) - c.unresolvedSymbols[path] = result + c.unresolvedSymbols.intern(path, result) result.SetParent(parentSymbol) - c.typeAliasLinks.Get(result).declaredType = c.unresolvedType + c.typeAliasLinks.Get(result).declaredType.intern(c.unresolvedType) } return result } @@ -23998,7 +26443,7 @@ func (c *Checker) getTypeFromClassOrInterfaceReference(node *ast.Node, symbol *a // of the class or interface. localTypeArguments := c.fillMissingTypeArguments(c.getTypeArgumentsFromNode(node), typeParameters, minTypeArgumentCount, isJs) typeArguments := append(d.OuterTypeParameters(), localTypeArguments...) - return c.createTypeReferenceEx(t, typeArguments, ObjectFlagsFromTypeNode) + return c.createTypeReference(t, typeArguments) } if c.checkNoTypeArguments(node, symbol) { return t @@ -24093,11 +26538,11 @@ func (c *Checker) createNormalizedTypeReference(target *Type, typeArguments []*T return c.createTypeReference(target, typeArguments) } -func (c *Checker) createNormalizedTupleTypeEx(target *Type, elementTypes []*Type, objectFlags ObjectFlags) *Type { +func (c *Checker) createNormalizedTupleType(target *Type, elementTypes []*Type) *Type { d := target.AsTupleType() if d.combinedFlags&ElementFlagsNonRequired == 0 { // No need to normalize when we only have regular required elements - return c.createTypeReferenceEx(target, elementTypes, objectFlags) + return c.createTypeReference(target, elementTypes) } if d.combinedFlags&ElementFlagsVariadic != 0 { for i, e := range elementTypes { @@ -24111,7 +26556,7 @@ func (c *Checker) createNormalizedTupleTypeEx(target *Type, elementTypes []*Type }) if c.checkCrossProductUnion(checkTypes) { return c.mapType(e, func(t *Type) *Type { - return c.createNormalizedTupleTypeEx(target, core.ReplaceElement(elementTypes, i, t), objectFlags) + return c.createNormalizedTupleType(target, core.ReplaceElement(elementTypes, i, t)) }) } } @@ -24136,15 +26581,11 @@ func (c *Checker) createNormalizedTupleTypeEx(target *Type, elementTypes []*Type case tupleTarget == c.emptyGenericType: return c.emptyObjectType case len(n.types) != 0: - return c.createTypeReferenceEx(tupleTarget, n.types, objectFlags) + return c.createTypeReference(tupleTarget, n.types) } return tupleTarget } -func (c *Checker) createNormalizedTupleType(target *Type, elementTypes []*Type) *Type { - return c.createNormalizedTupleTypeEx(target, elementTypes, ObjectFlagsNone) -} - type TupleNormalizer struct { c *Checker types []*Type @@ -24170,10 +26611,11 @@ func (n *TupleNormalizer) normalize(c *Checker, elementTypes []*Type, elementInf } else if isTupleType(t) { spreadTypes := c.getElementTypes(t) if len(spreadTypes)+len(n.types) >= 10_000 { - message := core.IfElse(ast.IsPartOfTypeNode(c.currentNode), - diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent, - diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent) - c.error(c.currentNode, message) + c.reportAtCurrentNode(func(c *Checker, node *ast.Node) { + c.error(node, core.IfElse(node != nil && ast.IsPartOfTypeNode(node), + diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent, + diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent)) + }) return false } // Spread variadic elements with tuple types into the resulting tuple. @@ -24375,16 +26817,16 @@ func (c *Checker) getTypeFromTypeAliasReference(node *ast.Node, symbol *ast.Symb if symbol.CheckFlags()&ast.CheckFlagsUnresolved != 0 { alias := &TypeAlias{symbol: symbol, typeArguments: core.Map(typeArguments, c.getTypeFromTypeNode)} key := getAliasKey(alias) - errorType := c.errorTypes[key] + errorType, _ := c.errorTypes.get(key) if errorType == nil { errorType = c.newIntrinsicType(TypeFlagsAny, "error") errorType.alias = alias - c.errorTypes[key] = errorType + c.errorTypes.intern(key, errorType) } return errorType } t := c.getDeclaredTypeOfSymbol(symbol) - typeParameters := c.typeAliasLinks.Get(symbol).typeParameters + typeParameters := c.getTypeParametersOfTypeAlias(symbol) if len(typeParameters) != 0 { numTypeArguments := len(typeArguments) minTypeArgumentCount := c.getMinTypeArgumentCount(typeParameters) @@ -24446,13 +26888,24 @@ func (c *Checker) getTypeAliasInstantiation(symbol *ast.Symbol, typeArguments [] links := c.typeAliasLinks.Get(symbol) typeParameters := links.typeParameters key := getTypeAliasInstantiationKey(typeArguments, alias) - instantiation := links.instantiations[key] - if instantiation == nil { + if instantiation, _ := links.instantiations.cached(c, key); instantiation != nil { + return instantiation + } + // The instantiation may fail with an error that reusing it must replay; + // see "Instantiation limits". + reports := c.startCurrentNodeErrors() + links.instantiations.begin(c, key) + result := c.errorType + if !c.beginInstantiation() { mapper := newTypeMapper(typeParameters, c.fillMissingTypeArguments(typeArguments, typeParameters, c.getMinTypeArgumentCount(typeParameters), ast.IsInJSFile(symbol.ValueDeclaration()))) - instantiation = c.instantiateTypeWithAlias(t, mapper, alias) - links.instantiations[key] = instantiation + result = c.instantiateTypeWithAlias(t, mapper, alias) } - return instantiation + if !c.endInstantiation(reports) { + return c.errorType + } + links.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) + c.endMemo() + return result } func isLocalTypeAlias(symbol *ast.Symbol) bool { @@ -24461,6 +26914,28 @@ func isLocalTypeAlias(symbol *ast.Symbol) bool { } func (c *Checker) getDeclaredTypeOfSymbol(symbol *ast.Symbol) *Type { + key := memoKeyOf(symbol, memoDeclaredType) + var t *Type + switch { + case symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 && symbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface|ast.SymbolFlagsTypeParameter) == 0: + if links := c.typeAliasLinks.TryGet(symbol); links != nil && c.memoErrorStates == 0 { + t = links.declaredType.peek() + } + case symbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface|ast.SymbolFlagsTypeParameter|ast.SymbolFlagsEnum|ast.SymbolFlagsEnumMember|ast.SymbolFlagsAlias) != 0: + if links := c.declaredTypeLinks.TryGet(symbol); links != nil { + t = links.declaredType.peek() + } + } + if t != nil && c.readsWithoutMemo(key) { + return t + } + c.beginMemo(key) + result := c.getDeclaredTypeOfSymbolUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getDeclaredTypeOfSymbolUncached(symbol *ast.Symbol) *Type { result := c.tryGetDeclaredTypeOfSymbol(symbol) if result == nil { result = c.errorType @@ -24569,9 +27044,8 @@ func (c *Checker) getOuterTypeParameters(node *ast.Node, includeThisTypes bool) ast.KindConditionalType: outerTypeParameters := c.getOuterTypeParameters(node, includeThisTypes) if (kind == ast.KindFunctionExpression || kind == ast.KindArrowFunction || ast.IsObjectLiteralMethod(node)) && c.isContextSensitive(node) { - signature := core.FirstOrNil(c.getSignaturesOfType(c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)), SignatureKindCall)) - if signature != nil && len(signature.TypeParameters()) != 0 { - return append(outerTypeParameters, signature.TypeParameters()...) + if typeParameters := c.getSignatureFromDeclaration(node).TypeParameters(); len(typeParameters) != 0 { + return append(outerTypeParameters, typeParameters...) } } if kind == ast.KindMappedType { @@ -24631,20 +27105,21 @@ func (c *Checker) appendTypeParameters(typeParameters []*Type, declarations []*a func (c *Checker) getDeclaredTypeOfTypeParameter(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if links.declaredType == nil { - links.declaredType = c.newTypeParameter(symbol) + if links.declaredType.cached(c) == nil { + links.declaredType.setIdentity(c, c.newTypeParameter(symbol)) } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getDeclaredTypeOfTypeAlias(symbol *ast.Symbol) *Type { links := c.typeAliasLinks.Get(symbol) - if links.declaredType == nil { + if links.declaredType.cached(c) == nil { // Note that we use the links object as the target here because the symbol object is used as the unique // identity for resolution of the 'type' property in SymbolLinks. - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameDeclaredType) { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameDeclaredType, &links.declaredType.memoHeader) { return c.errorType } + reports := c.startCurrentNodeErrors() declaration := core.Find(symbol.Declarations(), ast.IsTypeOrJSTypeAliasDeclaration) typeNode := declaration.Type() t := c.getTypeFromTypeNode(typeNode) @@ -24654,8 +27129,7 @@ func (c *Checker) getDeclaredTypeOfTypeAlias(symbol *ast.Symbol) *Type { // Initialize the instantiation cache for generic type aliases. The declared type corresponds to // an instantiation of the type alias with the type parameters supplied as type arguments. links.typeParameters = typeParameters - links.instantiations = make(map[CacheHashKey]*Type) - links.instantiations[getTypeListKey(typeParameters)] = t + links.instantiations.intern(getTypeListKey(typeParameters), t) } if t == c.intrinsicMarkerType && symbol.Name() == "BuiltinIteratorReturn" { t = c.getBuiltinIteratorReturnType() @@ -24668,16 +27142,18 @@ func (c *Checker) getDeclaredTypeOfTypeAlias(symbol *ast.Symbol) *Type { c.error(errorNode, diagnostics.Type_alias_0_circularly_references_itself, c.symbolToString(symbol)) t = c.errorType } - if links.declaredType == nil { - links.declaredType = t + nodeReports := c.endCurrentNodeErrors(reports) + if links.declaredType.peek() == nil { + links.declaredType.setReported(c, t, nodeReports) } + return links.declaredType.peek() } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getDeclaredTypeOfEnum(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if !(links.declaredType != nil) { + if !(links.declaredType.cached(c) != nil) { var memberTypeList []*Type for _, declaration := range symbol.Declarations() { if declaration.Kind == ast.KindEnumDeclaration { @@ -24691,7 +27167,7 @@ func (c *Checker) getDeclaredTypeOfEnum(symbol *ast.Symbol) *Type { } else { memberType = c.createComputedEnumType(memberSymbol) } - c.declaredTypeLinks.Get(memberSymbol).declaredType = c.getFreshTypeOfLiteralType(memberType) + c.declaredTypeLinks.Get(memberSymbol).declaredType.setIdentity(c, c.getFreshTypeOfLiteralType(memberType)) memberTypeList = append(memberTypeList, memberType) } } @@ -24707,9 +27183,9 @@ func (c *Checker) getDeclaredTypeOfEnum(symbol *ast.Symbol) *Type { enumType.flags |= TypeFlagsEnumLiteral enumType.symbol = symbol } - links.declaredType = enumType + links.declaredType.setIdentity(c, enumType) } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getEnumMemberValue(node *ast.Node) evaluator.Result { @@ -24729,19 +27205,25 @@ func (c *Checker) createComputedEnumType(symbol *ast.Symbol) *Type { func (c *Checker) getDeclaredTypeOfEnumMember(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if !(links.declaredType != nil) { + if !(links.declaredType.cached(c) != nil) { enumType := c.getDeclaredTypeOfEnum(c.getParentOfSymbol(symbol)) - if links.declaredType == nil { - links.declaredType = enumType + if links.declaredType.cached(c) == nil { + links.declaredType.setIdentity(c, enumType) } } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) computeEnumMemberValues(node *ast.Node) { + c.beginMemo(memoKeyOf(node, memoEnumMemberValue)) + c.computeEnumMemberValuesUncached(node) + c.endMemo() +} + +func (c *Checker) computeEnumMemberValuesUncached(node *ast.Node) { nodeLinks := c.nodeLinks.Get(node) - if !(nodeLinks.flags&NodeCheckFlagsEnumValuesComputed != 0) { - nodeLinks.flags |= NodeCheckFlagsEnumValuesComputed + if nodeLinks.flags&NodeCheckFlagsEnumValuesComputed == 0 { + setFlagMemoBits(c, memoKeyOf(node, memoEnumMemberValue), &nodeLinks.flags, NodeCheckFlagsEnumValuesComputed, NodeCheckFlagsEnumValuesComputed) autoValue := new(jsnum.Number) var previous *ast.Node for _, member := range node.Members() { @@ -24818,8 +27300,6 @@ func (c *Checker) computeConstantEnumMemberValue(member *ast.Node) evaluator.Res c.error(initializer, diagnostics.X_const_enum_member_initializers_must_be_constant_expressions) case member.Parent.Flags&ast.NodeFlagsAmbient != 0: c.error(initializer, diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression) - default: - c.checkTypeAssignableTo(c.checkExpression(initializer), c.numberType, initializer, diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values) } return result } @@ -24896,36 +27376,37 @@ func (c *Checker) evaluateEnumMember(expr *ast.Node, symbol *ast.Symbol, locatio func (c *Checker) getDeclaredTypeOfAlias(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if links.declaredType == nil { - links.declaredType = c.getDeclaredTypeOfSymbol(c.resolveAlias(symbol)) + if links.declaredType.cached(c) == nil { + links.declaredType.set(c, c.getDeclaredTypeOfSymbol(c.resolveAlias(symbol))) } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getTypeFromTypeQueryNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { // TypeScript 1.0 spec (April 2014): 3.6.3 // The expression is processed as an identifier expression (section 4.3) // or property access expression(section 4.10), // the widened type(section 3.9) of which becomes the result. t := c.checkExpressionWithTypeArguments(node) - links.resolvedType = c.getRegularTypeOfLiteralType(c.getWidenedType(t)) + links.resolvedType.set(c, c.getRegularTypeOfLiteralType(c.getWidenedType(t))) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromArrayOrTupleTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { target := c.getArrayOrTupleTargetType(node) if target == c.emptyGenericType { - links.resolvedType = c.emptyObjectType + links.resolvedType.set(c, c.emptyObjectType) } else if !(node.Kind == ast.KindTupleType && core.Some(node.Elements(), c.isVariadicTupleElement)) && c.isDeferredTypeReferenceNode(node, false) { if node.Kind == ast.KindTupleType && len(node.Elements()) == 0 { - links.resolvedType = target + links.resolvedType.set(c, target) } else { - links.resolvedType = c.createDeferredTypeReference(target, node, nil /*mapper*/, nil /*alias*/) + // The deferred reference is identified by the node, so it outlives a cycle. + links.resolvedType.setIdentity(c, c.createDeferredTypeReference(target, node, nil /*mapper*/, nil /*alias*/)) } } else { var elementTypes []*Type @@ -24935,13 +27416,13 @@ func (c *Checker) getTypeFromArrayOrTupleTypeNode(node *ast.Node) *Type { elementTypes = core.Map(node.Elements(), c.getTypeFromTypeNode) } if target.objectFlags&ObjectFlagsTuple != 0 { - links.resolvedType = c.createNormalizedTupleTypeEx(target, elementTypes, ObjectFlagsFromTypeNode) + links.resolvedType.set(c, c.createNormalizedTupleType(target, elementTypes)) } else { - links.resolvedType = c.createTypeReferenceEx(target, elementTypes, ObjectFlagsFromTypeNode) + links.resolvedType.set(c, c.createTypeReference(target, elementTypes)) } } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) isVariadicTupleElement(node *ast.Node) bool { @@ -24966,14 +27447,14 @@ func (c *Checker) isReadonlyTypeOperator(node *ast.Node) bool { func (c *Checker) getTypeFromNamedTupleTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { if node.AsNamedTupleMember().DotDotDotToken != nil { - links.resolvedType = c.getTypeFromRestTypeNode(node) + links.resolvedType.set(c, c.getTypeFromRestTypeNode(node)) } else { - links.resolvedType = c.addOptionalityEx(c.getTypeFromTypeNode(node.Type()), true /*isProperty*/, node.QuestionToken() != nil) + links.resolvedType.set(c, c.addOptionalityEx(c.getTypeFromTypeNode(node.Type()), true /*isProperty*/, node.QuestionToken() != nil)) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromRestTypeNode(node *ast.Node) *Type { @@ -25011,16 +27492,16 @@ func (c *Checker) getTypeFromOptionalTypeNode(node *ast.Node) *Type { func (c *Checker) getTypeFromUnionTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { alias := c.getAliasForTypeNode(node) - links.resolvedType = c.getUnionTypeEx(core.Map(node.AsUnionTypeNode().Types.Nodes, c.getTypeFromTypeNode), UnionReductionLiteral, alias, nil /*origin*/) + links.resolvedType.set(c, c.getUnionTypeEx(core.Map(node.AsUnionTypeNode().Types.Nodes, c.getTypeFromTypeNode), UnionReductionLiteral, alias, nil /*origin*/)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromIntersectionTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { alias := c.getAliasForTypeNode(node) types := core.Map(node.AsIntersectionTypeNode().Types.Nodes, c.getTypeFromTypeNode) // We perform no supertype reduction for X & {} or {} & X, where X is one of string, number, bigint, @@ -25034,14 +27515,14 @@ func (c *Checker) getTypeFromIntersectionTypeNode(node *ast.Node) *Type { noSupertypeReduction = t.flags&(TypeFlagsString|TypeFlagsNumber|TypeFlagsBigInt) != 0 || t.flags&TypeFlagsTemplateLiteral != 0 && c.isPatternLiteralType(t) } } - links.resolvedType = c.getIntersectionTypeEx(types, core.IfElse(noSupertypeReduction, IntersectionFlagsNoSupertypeReduction, 0), alias) + links.resolvedType.set(c, c.getIntersectionTypeEx(types, core.IfElse(noSupertypeReduction, IntersectionFlagsNoSupertypeReduction, 0), alias)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromTemplateTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { spans := node.AsTemplateLiteralTypeNode().TemplateSpans texts := make([]string, len(spans.Nodes)+1) types := make([]*Type, len(spans.Nodes)) @@ -25050,28 +27531,31 @@ func (c *Checker) getTypeFromTemplateTypeNode(node *ast.Node) *Type { texts[i+1] = span.AsTemplateLiteralTypeSpan().Literal.Text() types[i] = c.getTypeFromTypeNode(span.Type()) } - links.resolvedType = c.getTemplateLiteralType(texts, types) + links.resolvedType.set(c, c.getTemplateLiteralType(texts, types)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromMappedTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { t := c.newObjectType(ObjectFlagsMapped, node.Symbol()) t.AsMappedType().declaration = node.AsMappedTypeNode() t.alias = c.getAliasForTypeNode(node) - links.resolvedType = t - // Eagerly resolve the constraint type which forces an error if the constraint type circularly - // references itself through one or more type aliases. - c.getConstraintTypeFromMappedType(t) - } - return links.resolvedType + links.resolvedType.set(c, t) + } + t := links.resolvedType.cached(c) + // Eagerly resolve the constraint type which forces an error if the constraint type circularly + // references itself through one or more type aliases. This happens on every request rather + // than only when the type is created, so its errors do not depend on whether the type was + // created while checking another node. + c.getConstraintTypeFromMappedType(t) + return t } func (c *Checker) getTypeFromConditionalTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { checkType := c.getTypeFromTypeNode(node.AsConditionalTypeNode().CheckType) alias := c.getAliasForTypeNode(node) allOuterTypeParameters := c.getOuterTypeParameters(node, true /*includeThisTypes*/) @@ -25088,16 +27572,14 @@ func (c *Checker) getTypeFromConditionalTypeNode(node *ast.Node) *Type { isDistributive: checkType.flags&TypeFlagsTypeParameter != 0, inferTypeParameters: c.getInferTypeParameters(node), outerTypeParameters: outerTypeParameters, - instantiations: nil, alias: alias, } - links.resolvedType = c.getConditionalType(root, nil /*mapper*/, false /*forConstraint*/, nil) + links.resolvedType.set(c, c.getConditionalType(root, nil /*mapper*/, false /*forConstraint*/, nil)) if outerTypeParameters != nil { - root.instantiations = make(map[CacheHashKey]*Type) - root.instantiations[getConditionalTypeKey(outerTypeParameters, nil /*alias*/, false /*forConstraint*/)] = links.resolvedType + root.instantiations.intern(getConditionalTypeKey(outerTypeParameters, nil /*alias*/, false /*forConstraint*/), links.resolvedType.cached(c)) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getConditionalType(root *ConditionalRoot, mapper *TypeMapper, forConstraint bool, alias *TypeAlias) *Type { @@ -25111,7 +27593,7 @@ func (c *Checker) getConditionalType(root *ConditionalRoot, mapper *TypeMapper, // cases we increment the tail recursion counter and stop after 1000 iterations. for { if tailCount == 1000 { - c.error(c.currentNode, diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) + c.errorAtCurrentNode(diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) return c.errorType } checkType := c.instantiateType(c.getActualTypeVariable(root.checkType), mapper) @@ -25284,11 +27766,13 @@ func (c *Checker) getPermissiveInstantiation(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindPermissiveInstantiation, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) result := c.instantiateType(t, c.permissiveMapper) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } @@ -25297,34 +27781,52 @@ func (c *Checker) getRestrictiveInstantiation(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) result := c.instantiateType(t, c.restrictiveMapper) - c.cachedTypes[key] = result - // We set the following so we don't attempt to set the restrictive instance of a restrictive instance - // which is redundant - we'll produce new type identities, but all type params have already been mapped. - // This also gives us a way to detect restrictive instances upon comparisons and _disable_ the "distributeive constraint" - // assignability check for them, which is distinctly unsafe, as once you have a restrctive instance, all the type parameters - // are constrained to `unknown` and produce tons of false positives/negatives! - c.cachedTypes[CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: result.id}] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } +// isRestrictiveTypeParameter reports whether t is the restrictive form of a +// type parameter; see getRestrictiveTypeParameter. +func isRestrictiveTypeParameter(t *Type) bool { + return t.flags&TypeFlagsTypeParameter != 0 && t.AsTypeParameter().origin != nil && t.AsTypeParameter().origin.flags&TypeFlagsTypeParameter != 0 +} + func (c *Checker) getRestrictiveTypeParameter(t *Type) *Type { - if t.AsTypeParameter().constraint == nil && c.getConstraintDeclaration(t) == nil || t.AsTypeParameter().constraint == c.noConstraintType { + if c.isRestrictivelyUnconstrained(t) { return t } key := CachedTypeKey{kind: CachedTypeKindRestrictiveTypeParameter, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } result := c.newTypeParameter(t.symbol) - result.AsTypeParameter().constraint = c.noConstraintType - c.cachedTypes[key] = result + result.AsTypeParameter().constraint.intern(c.noConstraintType) + result.AsTypeParameter().origin = t + c.cachedTypes.intern(key, result) return result } +// isRestrictivelyUnconstrained reports whether t needs no restrictive form. +// For a declared type parameter, that is decided from its declaration rather +// than from whether its constraint is computed yet, which an implied +// constraint of an infer type parameter would make depend on what was asked +// first. +func (c *Checker) isRestrictivelyUnconstrained(t *Type) bool { + if isRestrictiveTypeParameter(t) { + return true + } + if t.symbol != nil && core.Some(t.symbol.Declarations(), ast.IsTypeParameterDeclaration) { + return isUnconstrainedTypeParameter(t) + } + return c.getConstraintOfTypeParameter(t) == nil +} + func (c *Checker) restrictiveMapperWorker(t *Type) *Type { if t.flags&TypeFlagsTypeParameter != 0 { return c.getRestrictiveTypeParameter(t) @@ -25341,57 +27843,53 @@ func (c *Checker) permissiveMapperWorker(t *Type) *Type { func (c *Checker) getTrueTypeFromConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedTrueType == nil { - d.resolvedTrueType = c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.mapper) - } - return d.resolvedTrueType + return c.memoCompute(&d.resolvedTrueType, func() *Type { + return c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.mapper) + }) } func (c *Checker) getFalseTypeFromConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedFalseType == nil { - d.resolvedFalseType = c.instantiateType(c.getTypeFromTypeNode(d.root.node.FalseType), d.mapper) - } - return d.resolvedFalseType + return c.memoCompute(&d.resolvedFalseType, func() *Type { + return c.instantiateType(c.getTypeFromTypeNode(d.root.node.FalseType), d.mapper) + }) } func (c *Checker) getInferredTrueTypeFromConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedInferredTrueType == nil { + return c.memoCompute(&d.resolvedInferredTrueType, func() *Type { if d.combinedMapper != nil { - d.resolvedInferredTrueType = c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.combinedMapper) - } else { - d.resolvedInferredTrueType = c.getTrueTypeFromConditionalType(t) + return c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.combinedMapper) } - } - return d.resolvedInferredTrueType + return c.getTrueTypeFromConditionalType(t) + }) } func (c *Checker) getTypeFromInferTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.getDeclaredTypeOfTypeParameter(c.getSymbolOfDeclaration(node.AsInferTypeNode().TypeParameter)) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getDeclaredTypeOfTypeParameter(c.getSymbolOfDeclaration(node.AsInferTypeNode().TypeParameter))) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromImportTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { n := node.AsImportTypeNode() if !ast.IsLiteralImportTypeNode(node) { c.error(n.Argument, diagnostics.String_literal_expected) - c.symbolNodeLinks.Get(node).resolvedSymbol = c.unknownSymbol - links.resolvedType = c.errorType - return links.resolvedType + c.symbolNodeLinks.Get(node).resolvedSymbol.set(c, c.unknownSymbol) + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) } targetMeaning := core.IfElse(n.IsTypeOf, ast.SymbolFlagsValue, ast.SymbolFlagsType) // TODO: Future work: support unions/generics/whatever via a deferred import-type innerModuleSymbol := c.resolveExternalModuleName(node, n.Argument.AsLiteralTypeNode().Literal, false /*ignoreErrors*/, c.getTypeFromImportAttributes(ast.GetImportAttributes(node))) if innerModuleSymbol == nil { - c.symbolNodeLinks.Get(node).resolvedSymbol = c.unknownSymbol - links.resolvedType = c.errorType - return links.resolvedType + c.symbolNodeLinks.Get(node).resolvedSymbol.set(c, c.unknownSymbol) + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) } moduleSymbol := c.resolveExternalModuleSymbol(innerModuleSymbol, false /*dontResolveAlias*/) if !ast.NodeIsMissing(n.Qualifier) { @@ -25426,28 +27924,28 @@ func (c *Checker) getTypeFromImportTypeNode(node *ast.Node) *Type { next := core.OrElse(symbolFromModule, symbolFromVariable) if next == nil { c.error(current, diagnostics.Namespace_0_has_no_exported_member_1, c.getFullyQualifiedName(currentNamespace, nil), scanner.DeclarationNameToString(current)) - links.resolvedType = c.errorType - return links.resolvedType + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) } - c.symbolNodeLinks.Get(current).resolvedSymbol = next - c.symbolNodeLinks.Get(current.Parent).resolvedSymbol = next + c.symbolNodeLinks.Get(current).resolvedSymbol.set(c, next) + c.symbolNodeLinks.Get(current.Parent).resolvedSymbol.set(c, next) currentNamespace = next } - links.resolvedType = c.resolveImportSymbolType(node, currentNamespace, targetMeaning) + links.resolvedType.set(c, c.resolveImportSymbolType(node, currentNamespace, targetMeaning)) } else { if c.getSymbolFlags(moduleSymbol)&targetMeaning != 0 { - links.resolvedType = c.resolveImportSymbolType(node, moduleSymbol, targetMeaning) + links.resolvedType.set(c, c.resolveImportSymbolType(node, moduleSymbol, targetMeaning)) } else { message := core.IfElse(targetMeaning == ast.SymbolFlagsValue, diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here, diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0) c.error(node, message, n.Argument.AsLiteralTypeNode().Literal.Text()) - c.symbolNodeLinks.Get(node).resolvedSymbol = c.unknownSymbol - links.resolvedType = c.errorType + c.symbolNodeLinks.Get(node).resolvedSymbol.set(c, c.unknownSymbol) + links.resolvedType.set(c, c.errorType) } } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getIdentifierChain(node *ast.Node) []*ast.Node { @@ -25459,7 +27957,7 @@ func (c *Checker) getIdentifierChain(node *ast.Node) []*ast.Node { func (c *Checker) resolveImportSymbolType(node *ast.Node, symbol *ast.Symbol, meaning ast.SymbolFlags) *Type { resolvedSymbol := c.resolveSymbol(symbol) - c.symbolNodeLinks.Get(node).resolvedSymbol = resolvedSymbol + c.symbolNodeLinks.Get(node).resolvedSymbol.set(c, resolvedSymbol) if meaning == ast.SymbolFlagsValue { // intentionally doesn't use resolved symbol so type is cached as expected on the alias return c.getInstantiationExpressionType(c.getTypeOfSymbol(symbol), node) @@ -25483,18 +27981,22 @@ func (c *Checker) getGlobalStrictFunctionType(name string) *Type { } func (c *Checker) getGlobalImportMetaExpressionType() *Type { - if c.deferredGlobalImportMetaExpressionType == nil { - // Create a synthetic type `ImportMetaExpression { meta: MetaProperty }` - symbol := c.newSymbol(ast.SymbolFlagsNone, "ImportMetaExpression") - importMetaType := c.getGlobalImportMetaType() - metaPropertySymbol := c.newSymbolEx(ast.SymbolFlagsProperty, "meta", ast.CheckFlagsReadonly) - metaPropertySymbol.SetParent(symbol) - c.valueSymbolLinks.Get(metaPropertySymbol).resolvedType = importMetaType - members := createSymbolTable([]*ast.Symbol{metaPropertySymbol}) - symbol.SetMembers(members, &c.symbolExtraArena) - c.deferredGlobalImportMetaExpressionType = c.newAnonymousType(symbol, members, nil, nil, nil) + if t := c.deferredGlobalImportMetaExpressionType.cached(c); t != nil { + return t } - return c.deferredGlobalImportMetaExpressionType + c.deferredGlobalImportMetaExpressionType.begin(c) + // Create a synthetic type `ImportMetaExpression { meta: MetaProperty }` + symbol := c.newSymbol(ast.SymbolFlagsNone, "ImportMetaExpression") + importMetaType := c.getGlobalImportMetaType() + metaPropertySymbol := c.newSymbolEx(ast.SymbolFlagsProperty, "meta", ast.CheckFlagsReadonly) + metaPropertySymbol.SetParent(symbol) + c.valueSymbolLinks.Get(metaPropertySymbol).resolvedType.intern(importMetaType) + members := createSymbolTable([]*ast.Symbol{metaPropertySymbol}) + symbol.SetMembers(members, &c.symbolExtraArena) + t := c.newAnonymousType(symbol, members, nil, nil, nil) + c.deferredGlobalImportMetaExpressionType.set(c, t) + c.endMemo() + return t } func (c *Checker) createIterableType(iteratedType *Type) *Type { @@ -25560,10 +28062,10 @@ func (c *Checker) getTupleTargetType(elementInfos []TupleElementInfo, readonly b return c.globalArrayType } key := getTupleKey(elementInfos, readonly) - t := c.tupleTypes[key] + t, _ := c.tupleTypes.get(key) if t == nil { t = c.createTupleTargetType(elementInfos, readonly) - c.tupleTypes[key] = t + c.tupleTypes.intern(key, t) } return t } @@ -25592,7 +28094,7 @@ func (c *Checker) createTupleTargetType(elementInfos []TupleElementInfo, readonl combinedFlags |= flags if combinedFlags&ElementFlagsVariable == 0 { property := c.newSymbolEx(ast.SymbolFlagsProperty|core.IfElse(flags&ElementFlagsOptional != 0, ast.SymbolFlagsOptional, 0), strconv.Itoa(i), core.IfElse(readonly, ast.CheckFlagsReadonly, 0)) - c.valueSymbolLinks.Get(property).resolvedType = typeParameter + c.valueSymbolLinks.Get(property).resolvedType.intern(typeParameter) // c.valueSymbolLinks.get(property).tupleLabelDeclaration = elementInfos[i].labeledDeclaration members.Set(property.Name(), property) } @@ -25601,25 +28103,27 @@ func (c *Checker) createTupleTargetType(elementInfos []TupleElementInfo, readonl fixedLength := members.Len() lengthSymbol := c.newSymbolEx(ast.SymbolFlagsProperty, "length", core.IfElse(readonly, ast.CheckFlagsReadonly, 0)) if combinedFlags&ElementFlagsVariable != 0 { - c.valueSymbolLinks.Get(lengthSymbol).resolvedType = c.numberType + c.valueSymbolLinks.Get(lengthSymbol).resolvedType.intern(c.numberType) } else { var literalTypes []*Type for i := minLength; i <= arity; i++ { literalTypes = append(literalTypes, c.getNumberLiteralType(jsnum.Number(i))) } - c.valueSymbolLinks.Get(lengthSymbol).resolvedType = c.getUnionType(literalTypes) + c.valueSymbolLinks.Get(lengthSymbol).resolvedType.intern(c.getUnionType(literalTypes)) } members.Set(lengthSymbol.Name(), lengthSymbol) t := c.newObjectType(ObjectFlagsTuple|ObjectFlagsReference, nil) d := t.AsTupleType() d.thisType = c.newTypeParameter(nil) d.thisType.AsTypeParameter().isThisType = true - d.thisType.AsTypeParameter().constraint = t + d.thisType.AsTypeParameter().constraint.intern(t) + for _, tp := range typeParameters { + tp.AsTypeParameter().origin = t + } d.allTypeParameters = append(typeParameters, d.thisType) - d.instantiations = make(map[CacheHashKey]*Type) - d.instantiations[getTypeListKey(d.TypeParameters())] = t + d.instantiations.intern(getTypeListKey(d.TypeParameters()), t) d.target = t - d.resolvedTypeArguments = d.TypeParameters() + d.resolvedTypeArguments.intern(d.TypeParameters()) d.declaredMembersResolved = true d.declaredMembers = members d.elementInfos = elementInfos @@ -25683,17 +28187,20 @@ func (c *Checker) isGenericIndexType(t *Type) bool { func (c *Checker) getGenericObjectFlags(t *Type) ObjectFlags { var combinedFlags ObjectFlags if t.flags&(TypeFlagsUnionOrIntersection|TypeFlagsSubstitution) != 0 { - if t.objectFlags&ObjectFlagsIsGenericTypeComputed == 0 { + if c.objectFlagsKnown(t, ObjectFlagsIsGenericTypeComputed) { + return t.objectFlags & ObjectFlagsIsGenericType + } + return c.objectFlagsCell(t, memoGenericObjectFlags, ObjectFlagsIsGenericTypeComputed, ObjectFlagsIsGenericType, false /*inProgress*/, func() ObjectFlags { + var flags ObjectFlags if t.flags&TypeFlagsUnionOrIntersection != 0 { for _, u := range t.Types() { - combinedFlags |= c.getGenericObjectFlags(u) + flags |= c.getGenericObjectFlags(u) } } else { - combinedFlags = c.getGenericObjectFlags(t.AsSubstitutionType().baseType) | c.getGenericObjectFlags(t.AsSubstitutionType().constraint) + flags = c.getGenericObjectFlags(t.AsSubstitutionType().baseType) | c.getGenericObjectFlags(t.AsSubstitutionType().constraint) } - t.objectFlags |= ObjectFlagsIsGenericTypeComputed | combinedFlags - } - return t.objectFlags & ObjectFlagsIsGenericType + return flags + }) } if t.flags&TypeFlagsInstantiableNonPrimitive != 0 || c.isGenericMappedType(t) || c.isGenericTupleType(t) { combinedFlags |= ObjectFlagsIsGenericObjectType @@ -25739,10 +28246,8 @@ func (c *Checker) isGenericReducibleType(t *Type) bool { func (c *Checker) isReducibleIntersection(t *Type) bool { d := t.AsIntersectionType() - if d.uniqueLiteralFilledInstantiation == nil { - d.uniqueLiteralFilledInstantiation = c.instantiateType(t, c.uniqueLiteralMapper) - } - return c.getReducedType(d.uniqueLiteralFilledInstantiation) != d.uniqueLiteralFilledInstantiation + instantiated := c.memoCompute(&d.uniqueLiteralFilledInstantiation, func() *Type { return c.instantiateType(t, c.uniqueLiteralMapper) }) + return c.getReducedType(instantiated) != instantiated } func (c *Checker) getUniqueLiteralTypeForTypeParameter(t *Type) *Type { @@ -25809,7 +28314,7 @@ func (c *Checker) newType(flags TypeFlags, objectFlags ObjectFlags, t *Type, kin t.objectFlags = objectFlags &^ (ObjectFlagsCouldContainTypeVariablesComputed | ObjectFlagsCouldContainTypeVariables | ObjectFlagsMembersResolved) t.id = TypeId(c.TypeCount) t.kind = kind //nolint:customlint - t.checker = c + t.checker = c.root if c.tracer != nil { c.tracer.RecordType(t) } @@ -25912,20 +28417,16 @@ func (c *Checker) tryCreateTypeReference(target *Type, typeArguments []*Type) *T } func (c *Checker) createTypeReference(target *Type, typeArguments []*Type) *Type { - return c.createTypeReferenceEx(target, typeArguments, ObjectFlagsNone) -} - -func (c *Checker) createTypeReferenceEx(target *Type, typeArguments []*Type, objectFlags ObjectFlags) *Type { id := getTypeListKey(typeArguments) intf := target.AsInterfaceType() - if t, ok := intf.instantiations[id]; ok { + if t, ok := intf.instantiations.cached(c, id); ok { return t } - t := c.newObjectType(ObjectFlagsReference|objectFlags|c.getPropagatingFlagsOfTypes(typeArguments, TypeFlagsNone), target.symbol) + t := c.newObjectType(ObjectFlagsReference|c.getPropagatingFlagsOfTypes(typeArguments, TypeFlagsNone), target.symbol) d := t.AsTypeReference() d.target = target - d.resolvedTypeArguments = typeArguments - intf.instantiations[id] = t + d.resolvedTypeArguments.intern(typeArguments) + intf.instantiations.intern(id, t) return t } @@ -25949,12 +28450,18 @@ func (c *Checker) cloneTypeReference(source *Type) *Type { t := c.newObjectType(ObjectFlagsReference, source.symbol) t.objectFlags = source.objectFlags &^ ObjectFlagsMembersResolved t.AsTypeReference().target = source.AsTypeReference().target - t.AsTypeReference().resolvedTypeArguments = source.AsTypeReference().resolvedTypeArguments + t.AsTypeReference().resolvedTypeArguments.intern(c.getTypeArguments(source)) return t } +// setStructuredTypeMembers sets the members of a type being created, which +// are then resolved. func (c *Checker) setStructuredTypeMembers(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) { t.objectFlags |= ObjectFlagsMembersResolved + c.setStructuredTypeData(t, members, callSignatures, constructSignatures, indexInfos) +} + +func (c *Checker) setStructuredTypeData(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) { data := t.AsStructuredType() data.members = members data.properties = c.getNamedMembers(members) @@ -26053,6 +28560,12 @@ func (c *Checker) newConditionalType(root *ConditionalRoot, mapper *TypeMapper, data.extendsType = c.instantiateType(root.extendsType, mapper) data.mapper = mapper data.combinedMapper = combinedMapper + // A restrictive instantiation maps the outer type parameters to their + // restrictive forms, which leave the distributive constraint meaningless; + // see getConstraintOfDistributiveConditionalType. + if mapper != nil { + data.restrictive = core.Some(root.outerTypeParameters, func(p *Type) bool { return isRestrictiveTypeParameter(mapper.Map(p)) }) + } return c.newType(TypeFlagsConditional, ObjectFlagsNone, data.AsType(), typeKindConditional) } @@ -26072,10 +28585,10 @@ func (c *Checker) newSignature(flags SignatureFlags, declaration *ast.Node, type sig.setTypeParameters(c, typeParameters) sig.parameters = parameters sig.setThisParameter(c, thisParameter) - sig.resolvedReturnType = resolvedReturnType - sig.setResolvedTypePredicate(c, resolvedTypePredicate) + sig.resolvedReturnType.intern(resolvedReturnType) + sig.initResolvedTypePredicate(c, resolvedTypePredicate) sig.minArgumentCount = int32(minArgumentCount) - sig.resolvedMinArgumentCount = -1 + sig.resolvedMinArgumentCount.intern(-1) return sig } @@ -26122,10 +28635,10 @@ func isFreshLiteralType(t *Type) bool { } func (c *Checker) getStringLiteralType(value string) *Type { - t := c.stringLiteralTypes[value] + t, _ := c.stringLiteralTypes.get(value) if t == nil { t = c.newLiteralType(TypeFlagsStringLiteral, value, nil) - c.stringLiteralTypes[value] = t + c.stringLiteralTypes.intern(value, t) } return t } @@ -26139,19 +28652,19 @@ func (c *Checker) getNumberLiteralType(value jsnum.Number) *Type { } return c.nanType } - t := c.numberLiteralTypes[value] + t, _ := c.numberLiteralTypes.get(value) if t == nil { t = c.newLiteralType(TypeFlagsNumberLiteral, value, nil) - c.numberLiteralTypes[value] = t + c.numberLiteralTypes.intern(value, t) } return t } func (c *Checker) getBigIntLiteralType(value jsnum.PseudoBigInt) *Type { - t := c.bigintLiteralTypes[value] + t, _ := c.bigintLiteralTypes.get(value) if t == nil { t = c.newLiteralType(TypeFlagsBigIntLiteral, value, nil) - c.bigintLiteralTypes[value] = t + c.bigintLiteralTypes.intern(value, t) } return t } @@ -26188,11 +28701,11 @@ func (c *Checker) getEnumLiteralType(value any, enumSymbol *ast.Symbol, symbol * // NaN cannot be used as a Go map key because NaN != NaN in IEEE 754, // so Go map lookups for NaN always miss. Cache NaN enum types separately by enum symbol. if v.IsNaN() { - t := c.enumNaNLiteralTypes[enumSymbol] + t, _ := c.enumNaNLiteralTypes.get(enumSymbol) if t == nil { t = c.newLiteralType(flags, value, nil) t.symbol = symbol - c.enumNaNLiteralTypes[enumSymbol] = t + c.enumNaNLiteralTypes.intern(enumSymbol, t) } return t } @@ -26200,11 +28713,11 @@ func (c *Checker) getEnumLiteralType(value any, enumSymbol *ast.Symbol, symbol * panic("Unhandled case in getEnumLiteralType") } key := EnumLiteralKey{enumSymbol: enumSymbol, value: value} - t := c.enumLiteralTypes[key] + t, _ := c.enumLiteralTypes.get(key) if t == nil { t = c.newLiteralType(flags, value, nil) t.symbol = symbol - c.enumLiteralTypes[key] = t + c.enumLiteralTypes.intern(key, t) } return t } @@ -26295,11 +28808,13 @@ func (c *Checker) getBaseTypeOfEnumLikeType(t *Type) *Type { func (c *Checker) getBaseTypeOfLiteralTypeUnion(t *Type) *Type { key := CachedTypeKey{kind: CachedTypeKindLiteralUnionBaseType, typeId: t.id} - if cached, ok := c.cachedTypes[key]; ok { + if cached, ok := c.cachedTypes.cached(c, key); ok { return cached } + c.cachedTypes.begin(c, key) result := c.mapType(t, c.getBaseTypeOfLiteralType) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } @@ -26469,10 +28984,12 @@ func (c *Checker) getUnionTypeEx(types []*Type, unionReduction UnionReduction, a id1, id2 = id2, id1 } key := UnionOfUnionKey{id1: id1, id2: id2, r: unionReduction, a: getAliasKey(alias)} - t := c.unionOfUnionTypes[key] + t, _ := c.unionOfUnionTypes.cached(c, key) if t == nil { + c.unionOfUnionTypes.begin(c, key) t = c.getUnionTypeWorker(types, unionReduction, alias, nil /*origin*/) - c.unionOfUnionTypes[key] = t + c.unionOfUnionTypes.set(c, key, t) + c.endMemo() } return t } @@ -26573,7 +29090,7 @@ func (c *Checker) getUnionTypeFromSortedList(types []*Type, precomputedObjectFla return types[0] } key := getUnionKey(types, origin, alias) - t := c.unionTypes[key] + t, _ := c.unionTypes.get(key) if t == nil { t = c.newUnionType(precomputedObjectFlags|c.getPropagatingFlagsOfTypes(types, TypeFlagsNullable), types) t.AsUnionType().origin = origin @@ -26581,13 +29098,13 @@ func (c *Checker) getUnionTypeFromSortedList(types []*Type, precomputedObjectFla if len(types) == 2 && types[0].flags&TypeFlagsBooleanLiteral != 0 && types[1].flags&TypeFlagsBooleanLiteral != 0 { t.flags |= TypeFlagsBoolean } - c.unionTypes[key] = t + c.unionTypes.intern(key, t) } return t } func (c *Checker) UnionTypes() iter.Seq[*Type] { - return maps.Values(c.unionTypes) + return c.unionTypes.values() } func (c *Checker) addTypesToUnion(sourceTypes []*Type, types []*Type) ([]*Type, TypeFlags) { @@ -26768,9 +29285,10 @@ func (c *Checker) removeSubtypes(types []*Type, hasObjectTypes bool) []*Type { return types } key := getTypeListKey(types) - if cached := c.subtypeReductionCache[key]; cached != nil { + if cached, _ := c.subtypeReductionCache.cached(c, key); cached != nil { return cached } + c.subtypeReductionCache.begin(c, key) // We assume that redundant primitive types have already been removed from the types array and that there // are no any and unknown types in the array. Thus, the only possible supertypes for primitive types are empty // object types, and if none of those are present we can exclude primitive types from the subtype check. @@ -26824,7 +29342,8 @@ func (c *Checker) removeSubtypes(types []*Type, hasObjectTypes bool) []*Type { if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "removeSubtypes_DepthLimit", map[string]any{"estimatedCount": estimatedCount}) } - c.error(c.currentNode, diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent) + c.errorAtCurrentNode(diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent) + c.endMemo() return nil } } @@ -26849,7 +29368,8 @@ func (c *Checker) removeSubtypes(types []*Type, hasObjectTypes bool) []*Type { } } reduced := c.typeListArena.Clone(types) - c.subtypeReductionCache[key] = reduced + c.subtypeReductionCache.set(c, key, reduced) + c.endMemo() return reduced } @@ -26996,8 +29516,9 @@ func (c *Checker) getIntersectionTypeEx(types []*Type, flags IntersectionFlags, } } key := getIntersectionKey(typeSet, flags, alias) - result := c.intersectionTypes[key] + result, _ := c.intersectionTypes.cached(c, key) if result == nil { + c.intersectionTypes.begin(c, key) if includes&TypeFlagsUnion != 0 { var reduced bool typeSet, reduced = c.intersectUnionsOfPrimitiveTypes(typeSet) @@ -27033,6 +29554,7 @@ func (c *Checker) getIntersectionTypeEx(types []*Type, flags IntersectionFlags, // the form X & A & C | X & A & D | X & B & C | X & B & D. If the estimated size of the resulting union type // exceeds 100000 constituents, report an error. if !c.checkCrossProductUnion(typeSet) { + c.endMemo() return c.errorType } constituents := c.getCrossProductIntersections(typeSet, flags) @@ -27041,16 +29563,34 @@ func (c *Checker) getIntersectionTypeEx(types []*Type, flags IntersectionFlags, // the denormalized origin has fewer constituents than the union itself. var origin *Type if core.Some(constituents, isIntersectionType) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) { - origin = c.newIntersectionType(ObjectFlagsNone, typeSet) + origin = c.getIntersectionTypeWithContent(ObjectFlagsNone, typeSet, nil) } result = c.getUnionTypeEx(constituents, UnionReductionLiteral, alias, origin) } } else { - result = c.newIntersectionType(objectFlags|c.getPropagatingFlagsOfTypes(types /*excludeKinds*/, TypeFlagsNullable), typeSet) - result.alias = alias + result = c.getIntersectionTypeWithContent(objectFlags|c.getPropagatingFlagsOfTypes(types /*excludeKinds*/, TypeFlagsNullable), typeSet, alias) } - c.intersectionTypes[key] = result + c.intersectionTypes.setIdentity(c, key, result) + c.endMemo() + } + return result +} + +// getIntersectionTypeWithContent returns the intersection type with the given +// constituents, flags, and alias. Different intersection cache keys can reduce +// to the same content, which should yield the same type. +func (c *Checker) getIntersectionTypeWithContent(objectFlags ObjectFlags, typeSet []*Type, alias *TypeAlias) *Type { + var b keyBuilder + b.writeTypes(typeSet) + b.writeUint32(uint32(objectFlags)) + b.writeAlias(alias) + key := b.hash() + if existing, _ := c.intersectionContentTypes.get(key); existing != nil { + return existing } + result := c.newIntersectionType(objectFlags, typeSet) + result.alias = alias + c.intersectionContentTypes.intern(key, result) return result } @@ -27487,7 +30027,7 @@ func (c *Checker) checkCrossProductUnion(types []*Type) bool { if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "checkCrossProductUnion_DepthLimit", map[string]any{"size": size}) } - c.error(c.currentNode, diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent) + c.errorAtCurrentNode(diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent) return false } return true @@ -27552,9 +30092,10 @@ func (c *Checker) getExtractStringType(t *Type) *Type { func (c *Checker) getLiteralTypeFromProperties(t *Type, include TypeFlags, includeOrigin bool) *Type { key := PropertiesTypesKey{typeId: t.id, include: include, includeOrigin: includeOrigin} - if cached, ok := c.propertiesTypes[key]; ok { + if cached, ok := c.propertiesTypes.cached(c, key); ok { return cached } + c.propertiesTypes.begin(c, key) var origin *Type if includeOrigin && t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0 || t.alias != nil { origin = c.newIndexType(t, IndexFlagsNone) @@ -27575,7 +30116,8 @@ func (c *Checker) getLiteralTypeFromProperties(t *Type, include TypeFlags, inclu } } result := c.getUnionTypeEx(types, UnionReductionLiteral, nil, origin) - c.propertiesTypes[key] = result + c.propertiesTypes.set(c, key, result) + c.endMemo() return result } @@ -27636,23 +30178,37 @@ func isInvalidComputedPropertyName(node *ast.Node) bool { } func (c *Checker) checkComputedPropertyName(node *ast.Node) *Type { + c.typeNodeLinks.Get(node).resolvedType.begin(c) + result := c.checkComputedPropertyNameUncached(node) + c.endMemo() + return result +} + +func (c *Checker) checkComputedPropertyNameUncached(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.circularConstraintType + if links.resolvedType.cached(c) == nil { if isInvalidComputedPropertyName(node) { - links.resolvedType = c.errorType - return links.resolvedType + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) + } + if !c.pushTypeResolution(node, TypeSystemPropertyNameComputedPropertyName, &links.resolvedType.memoHeader) { + return c.errorType + } + t := c.checkExpression(node.Expression()) + c.popTypeResolution() + if links.resolvedType.cached(c) != nil { + return links.resolvedType.cached(c) } - links.resolvedType = c.checkExpression(node.Expression()) + links.resolvedType.set(c, t) // This will allow types number, string, symbol or any. It will also allow enums, the unknown // type, and any union of these types (like string | number). - if links.resolvedType.flags&TypeFlagsNullable != 0 || - !c.isTypeAssignableToKind(links.resolvedType, TypeFlagsStringLike|TypeFlagsNumberLike|TypeFlagsESSymbolLike) && - !c.isTypeAssignableTo(links.resolvedType, c.stringNumberSymbolType) { + if links.resolvedType.cached(c).flags&TypeFlagsNullable != 0 || + !c.isTypeAssignableToKind(links.resolvedType.cached(c), TypeFlagsStringLike|TypeFlagsNumberLike|TypeFlagsESSymbolLike) && + !c.isTypeAssignableTo(links.resolvedType.cached(c), c.stringNumberSymbolType) { c.error(node, diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) isNoInferType(t *Type) bool { @@ -27691,11 +30247,11 @@ func (c *Checker) getIndexTypeForGenericType(t *Type, indexFlags IndexFlags) *Ty kind: core.IfElse(indexFlags&IndexFlagsStringsOnly != 0, CachedTypeKindStringIndexType, CachedTypeKindIndexType), typeId: t.id, } - if indexType := c.cachedTypes[key]; indexType != nil { + if indexType, _ := c.cachedTypes.cached(c, key); indexType != nil { return indexType } indexType := c.newIndexType(t, indexFlags&IndexFlagsStringsOnly) - c.cachedTypes[key] = indexType + c.cachedTypes.intern(key, indexType) return indexType } @@ -27796,11 +30352,11 @@ func (c *Checker) getIndexedAccessTypeOrUndefined(objectType *Type, indexType *T // Defer the operation by creating an indexed access type. persistentAccessFlags := accessFlags & AccessFlagsPersistent key := getIndexedAccessKey(objectType, indexType, persistentAccessFlags, alias) - t := c.indexedAccessTypes[key] + t, _ := c.indexedAccessTypes.get(key) if t == nil { t = c.newIndexedAccessType(objectType, indexType, persistentAccessFlags) t.alias = alias - c.indexedAccessTypes[key] = t + c.indexedAccessTypes.intern(key, t) } return t } @@ -27873,7 +30429,7 @@ func (c *Checker) getPropertyTypeForIndexType(originalObjectType *Type, objectTy return nil } if accessFlags&AccessFlagsCacheSymbol != 0 { - c.symbolNodeLinks.Get(accessNode).resolvedSymbol = prop + c.symbolNodeLinks.Get(accessNode).resolvedSymbol.set(c, prop) } if c.isThisPropertyAccessInConstructor(accessExpression, prop) { return c.autoType @@ -27972,7 +30528,7 @@ func (c *Checker) getPropertyTypeForIndexType(originalObjectType *Type, objectTy c.addDiagnostic(createDiagnosticForNode(accessExpression, diagnostics.Property_0_does_not_exist_on_type_1, indexType.AsLiteralType().value, c.TypeToString(objectType))) return c.undefinedType } else if indexType.flags&(TypeFlagsNumber|TypeFlagsString) != 0 { - types := core.Map(objectType.AsStructuredType().getProperties(), func(prop *ast.Symbol) *Type { + types := core.Map(objectType.AsStructuredType().getProperties(c), func(prop *ast.Symbol) *Type { return c.getTypeOfSymbol(prop) }) return c.getUnionType(append(types, c.undefinedType)) @@ -28253,11 +30809,11 @@ func (c *Checker) getSubstitutionType(baseType *Type, constraint *Type) *Type { func (c *Checker) getOrCreateSubstitutionType(baseType *Type, constraint *Type) *Type { key := SubstitutionTypeKey{baseId: baseType.id, constraintId: constraint.id} - if cached := c.substitutionTypes[key]; cached != nil { + if cached, _ := c.substitutionTypes.get(key); cached != nil { return cached } result := c.newSubstitutionType(baseType, constraint) - c.substitutionTypes[key] = result + c.substitutionTypes.intern(key, result) return result } @@ -28280,17 +30836,64 @@ func (c *Checker) getBaseConstraintOfType(t *Type) *Type { return nil } +// Base constraint walks +// +// A walk for a base constraint gives up on types nested 10 levels deep that +// are already on its stack, or nested 50 levels deep, so a base constraint +// computed inside a walk may depend on the types the walk came through. As +// more types on the stack only make a walk give up sooner, a base constraint +// whose own walk did not give up is the same wherever it is computed, and is +// kept; one whose walk gave up is kept only if the walk was started for it. +// A kept base constraint is reused inside a walk only where its own walk, +// whose depth is kept with it, stays within the first 10 levels, where +// nothing gives up. Elsewhere it is computed again inside that walk, as a +// distinct resolution so that re-entering it is still a cycle. + +const ( + baseConstraintFreeDepth = 10 + baseConstraintMaxDepth = 50 +) + +type baseConstraintWalk struct { + depth int32 // Deepest level the walk has reached + gaveUp bool +} + func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type { - constrained := t.AsConstrainedType() - if constrained == nil { - return t + if constrained := t.AsConstrainedType(); constrained != nil && constrained.resolvedBaseConstraint.peek() != nil { + // A resolved base constraint is only read. + if len(stack) != 0 { + if t.baseConstraintHeight.reaches(len(stack), baseConstraintFreeDepth) { + constraint, _, _ := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameBaseConstraintInWalk, nil) + return constraint + } + c.baseConstraintWalk.depth = max(c.baseConstraintWalk.depth, int32(len(stack))+int32(t.baseConstraintHeight)) + } + return constrained.resolvedBaseConstraint.cached(c) } - if constrained.resolvedBaseConstraint != nil { - return constrained.resolvedBaseConstraint + saveWalk := c.baseConstraintWalk + if len(stack) == 0 { + c.baseConstraintWalk = baseConstraintWalk{} } - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstraint) { - return c.circularConstraintType + c.beginMemo(memoKeyOf(t, memoBaseConstraint)) + result := c.getResolvedBaseConstraintUncached(t, stack) + c.endMemo() + if len(stack) == 0 { + c.baseConstraintWalk = saveWalk } + return result +} + +func (c *Checker) isBaseConstraintInProgress(t *Type) bool { + return c.isResolutionInProgress(t, TypeSystemPropertyNameResolvedBaseConstraint) || c.isResolutionInProgress(t, TypeSystemPropertyNameBaseConstraintInWalk) +} + +// walkBaseConstraint computes the base constraint of t inside the walk with +// stack, and returns it with the depth its own walk reached and whether its +// own walk gave up. +func (c *Checker) walkBaseConstraint(t *Type, stack []RecursionId) (*Type, int32, bool) { + saveWalk := c.baseConstraintWalk + c.baseConstraintWalk = baseConstraintWalk{depth: int32(len(stack))} var constraint *Type // We always explore at least 10 levels of nested constraints. Thereafter, we continue to explore // up to 50 levels of nested constraints provided there are no "deeply nested" types on the stack @@ -28298,18 +30901,64 @@ func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type // levels of nesting, we are presumably exploring a repeating pattern with a long cycle that hasn't // yet triggered the deeply nested limiter. We have no test cases that actually get to 50 levels of // nesting, so it is effectively just a safety stop. - identity := getRecursionIdentity(t) - if len(stack) < 10 || len(stack) < 50 && !slices.Contains(stack, identity) { + identity := c.getRecursionIdentity(t) + if len(stack) < baseConstraintFreeDepth || len(stack) < baseConstraintMaxDepth && !slices.Contains(stack, identity) { constraint = c.computeBaseConstraint(c.getSimplifiedType(t /*writing*/, false), append(stack, identity)) + } else { + c.baseConstraintWalk.gaveUp = true + } + walk := c.baseConstraintWalk + c.baseConstraintWalk = baseConstraintWalk{depth: max(saveWalk.depth, walk.depth), gaveUp: saveWalk.gaveUp || walk.gaveUp} + return constraint, walk.depth - int32(len(stack)), walk.gaveUp +} + +func (c *Checker) getResolvedBaseConstraintUncached(t *Type, stack []RecursionId) *Type { + constrained := t.AsConstrainedType() + if constrained == nil { + return t + } + if constrained.resolvedBaseConstraint.cached(c) != nil { + return constrained.resolvedBaseConstraint.cached(c) + } + constraint, walkHeight, gaveUp := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameResolvedBaseConstraint, &constrained.resolvedBaseConstraint.memoHeader) + if gaveUp && len(stack) != 0 { + // Depends on the walk it was computed in. + return constraint + } + if constrained.resolvedBaseConstraint.cached(c) == nil { + t.baseConstraintHeight = heightOf(walkHeight) + constrained.resolvedBaseConstraint.set(c, constraint) + } + return constraint +} + +// resolveBaseConstraint computes the base constraint of t inside the walk +// with stack as the resolution of propertyName, and returns it with the depth +// its own walk reached and whether its own walk gave up. +func (c *Checker) resolveBaseConstraint(t *Type, stack []RecursionId, propertyName TypeSystemPropertyName, memo *memoHeader) (*Type, int32, bool) { + if !c.pushTypeResolution(t, propertyName, memo) { + return c.circularConstraintType, 0, false } + constraint, height, gaveUp := c.walkBaseConstraint(t, stack) if !c.popTypeResolution() { if t.flags&TypeFlagsTypeParameter != 0 { errorNode := c.getConstraintDeclaration(t) if errorNode != nil { - diagnostic := c.error(errorNode, diagnostics.Type_parameter_0_has_a_circular_constraint, c.TypeToString(t)) - if c.currentNode != nil && !isNodeDescendantOf(errorNode, c.currentNode) && !isNodeDescendantOf(c.currentNode, errorNode) { - diagnostic.AddRelatedInfo(NewDiagnosticForNode(c.currentNode, diagnostics.Circularity_originates_in_type_at_this_location)) - } + typeString := c.TypeToString(t) + // The error is located at the constraint, not the current node, and the + // circularity is intrinsic to the declarations, so it is reported once + // and the circular result is kept. Discarding it would let a later + // computation reuse cycle participants that hide the cycle. + // Only the cycle of an instantiation originates at a use; that of a + // declared type parameter is found by checking its declaration, and + // whichever use happens to find it first is no origin. + instantiated := t.AsTypeParameter().target != nil + c.reportAtCurrentNodeOnce(func(c *Checker, node *ast.Node) { + diagnostic := c.error(errorNode, diagnostics.Type_parameter_0_has_a_circular_constraint, typeString) + if instantiated && node != nil && !isNodeDescendantOf(errorNode, node) && !isNodeDescendantOf(node, errorNode) { + diagnostic.AddRelatedInfo(NewDiagnosticForNode(node, diagnostics.Circularity_originates_in_type_at_this_location)) + } + }) } } constraint = c.circularConstraintType @@ -28317,10 +30966,7 @@ func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type if constraint == nil { constraint = c.noConstraintType } - if constrained.resolvedBaseConstraint == nil { - constrained.resolvedBaseConstraint = constraint - } - return constraint + return constraint, height, gaveUp } func (c *Checker) computeBaseConstraint(t *Type, stack []RecursionId) *Type { @@ -28396,12 +31042,12 @@ func (c *Checker) computeBaseConstraint(t *Type, stack []RecursionId) *Type { } return c.getNextBaseConstraint(c.getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.AsIndexedAccessType().accessFlags, nil, nil), stack) case t.flags&TypeFlagsConditional != 0: - if c.conditionalConstraintDepth >= 100 { + if c.depthLimitReached(&c.conditionalConstraintDepth, 100) { return nil } - c.conditionalConstraintDepth++ + c.enterDepthLimit(&c.conditionalConstraintDepth) constraint := c.getConstraintFromConditionalType(t) - c.conditionalConstraintDepth-- + c.exitDepthLimit(&c.conditionalConstraintDepth) return c.getNextBaseConstraint(constraint, stack) case t.flags&TypeFlagsSubstitution != 0: return c.getNextBaseConstraint(c.getSubstitutionIntersection(t), stack) @@ -28562,7 +31208,7 @@ func (c *Checker) markPropertyAsReferenced(prop *ast.Symbol, nodeForCheckWriteOn if prop.CheckFlags()&ast.CheckFlagsInstantiated != 0 { target = c.valueSymbolLinks.Get(prop).target } - c.symbolReferenceLinks.Get(target).referenceKinds |= ast.SymbolFlagsAll + c.symbolReferenced(target, ast.SymbolFlagsAll) } func (c *Checker) expandSignatureParametersWithTupleMembers(signature *Signature, restType *TypeReference, restIndex int, restSymbol *ast.Symbol) []*ast.Symbol { @@ -28582,9 +31228,9 @@ func (c *Checker) expandSignatureParametersWithTupleMembers(signature *Signature symbol := c.newSymbolEx(ast.SymbolFlagsFunctionScopedVariable, associatedNames[i], checkFlags) links := c.valueSymbolLinks.Get(symbol) if flags&ElementFlagsRest != 0 { - links.resolvedType = c.createArrayType(t) + links.resolvedType.setIdentity(c, c.createArrayType(t)) } else { - links.resolvedType = t + links.resolvedType.setIdentity(c, t) } expanded = append(expanded, symbol) } @@ -28638,14 +31284,16 @@ func getNameFromIndexInfo(info *IndexInfo) string { func (c *Checker) isUnknownLikeUnionType(t *Type) bool { if c.strictNullChecks && t.flags&TypeFlagsUnion != 0 { - if t.objectFlags&ObjectFlagsIsUnknownLikeUnionComputed == 0 { - t.objectFlags |= ObjectFlagsIsUnknownLikeUnionComputed + if c.objectFlagsKnown(t, ObjectFlagsIsUnknownLikeUnionComputed) { + return t.objectFlags&ObjectFlagsIsUnknownLikeUnion != 0 + } + return c.objectFlagsCell(t, memoUnknownLikeUnion, ObjectFlagsIsUnknownLikeUnionComputed, ObjectFlagsIsUnknownLikeUnion, true /*inProgress*/, func() ObjectFlags { types := t.Types() if len(types) >= 3 && types[0].flags&TypeFlagsUndefined != 0 && types[1].flags&TypeFlagsNull != 0 && core.Some(types, c.IsEmptyAnonymousObjectType) { - t.objectFlags |= ObjectFlagsIsUnknownLikeUnion + return ObjectFlagsIsUnknownLikeUnion } - } - return t.objectFlags&ObjectFlagsIsUnknownLikeUnion != 0 + return 0 + }) != 0 } return false } @@ -28760,16 +31408,24 @@ func (c *Checker) getSimplifiedIndexType(t *Type) *Type { // the target of an assignment. func (c *Checker) getSimplifiedIndexedAccessType(t *Type, writing bool) *Type { key := CachedTypeKey{kind: core.IfElse(writing, CachedTypeKindIndexedAccessForWriting, CachedTypeKindIndexedAccessForReading), typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { - return core.IfElse(cached == c.circularConstraintType, t, cached) + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { + return cached + } + propertyName := core.IfElse(writing, TypeSystemPropertyNameSimplifiedForWriting, TypeSystemPropertyNameSimplifiedForReading) + if c.isResolvingAnywhere(t, propertyName) { + // Resolve circular references to t itself while simplifying. + return t } - c.cachedTypes[key] = t + c.cachedTypes.begin(c, key) + c.beginTypeResolution(t, propertyName, nil) result := c.getSimplifiedIndexedAccessTypeWorker(t, writing) if result != t { // If the simplification is a union type that includes t, remove t from the type. result = c.removeType(result, t) - c.cachedTypes[key] = result } + c.cachedTypes.set(c, key, result) + c.popTypeResolution() + c.endMemo() return result } @@ -28851,11 +31507,13 @@ func (c *Checker) distributeIndexOverObjectType(objectType *Type, indexType *Typ func (c *Checker) getSimplifiedConditionalType(t *Type, writing bool) *Type { key := CachedTypeKey{kind: core.IfElse(writing, CachedTypeKindSimplifiedConditionalTypeForWriting, CachedTypeKindSimplifiedConditionalTypeForReading), typeId: t.id} - if cached, ok := c.cachedTypes[key]; ok { + if cached, ok := c.cachedTypes.cached(c, key); ok { return cached } + c.cachedTypes.begin(c, key) result := c.getSimplifiedConditionalTypeWorker(t, writing) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } @@ -28945,10 +31603,17 @@ func (c *Checker) getSingleBaseForNonAugmentingSubtype(t *Type) *Type { return nil } key := CachedTypeKey{kind: CachedTypeKindEquivalentBaseType, typeId: t.id} - if t.objectFlags&ObjectFlagsIdenticalBaseTypeCalculated != 0 { - return c.cachedTypes[key] + if cached, ok := c.cachedTypes.cached(c, key); ok { + return cached } - t.objectFlags |= ObjectFlagsIdenticalBaseTypeCalculated + c.cachedTypes.begin(c, key) + result := c.getSingleBaseForNonAugmentingSubtypeUncached(t) + c.cachedTypes.set(c, key, result) + c.endMemo() + return result +} + +func (c *Checker) getSingleBaseForNonAugmentingSubtypeUncached(t *Type) *Type { target := t.Target() if target.objectFlags&ObjectFlagsClass != 0 { baseTypeNode := getBaseTypeNodeOfClass(target) @@ -28976,36 +31641,32 @@ func (c *Checker) getSingleBaseForNonAugmentingSubtype(t *Type) *Type { if len(c.getTypeArguments(t)) > len(typeParameters) { instantiatedBase = c.getTypeWithThisArgument(instantiatedBase, core.LastOrNil(c.getTypeArguments(t)), false) } - c.cachedTypes[key] = instantiatedBase return instantiatedBase } func (c *Checker) getModifiersTypeFromMappedType(t *Type) *Type { m := t.AsMappedType() - if m.modifiersType == nil { + return c.memoCompute(&m.modifiersType, func() *Type { if c.isMappedTypeWithKeyofConstraintDeclaration(t) { // If the constraint declaration is a 'keyof T' node, the modifiers type is T. We check // AST nodes here because, when T is a non-generic type, the logic below eagerly resolves // 'keyof T' to a literal union type and we can't recover T from that type. - m.modifiersType = c.instantiateType(c.getTypeFromTypeNode(c.getConstraintDeclarationForMappedType(t).Type()), m.mapper) - } else { - // Otherwise, get the declared constraint type, and if the constraint type is a type parameter, - // get the constraint of that type parameter. If the resulting type is an indexed type 'keyof T', - // the modifiers type is T. Otherwise, the modifiers type is unknown. - declaredType := c.getTypeFromMappedTypeNode(m.declaration.AsNode()) - constraint := c.getConstraintTypeFromMappedType(declaredType) - extendedConstraint := constraint - if constraint != nil && constraint.flags&TypeFlagsTypeParameter != 0 { - extendedConstraint = c.getConstraintOfTypeParameter(getNonDistributedTypeParameter(constraint)) - } - if extendedConstraint != nil && extendedConstraint.flags&TypeFlagsIndex != 0 { - m.modifiersType = c.instantiateType(extendedConstraint.AsIndexType().target, m.mapper) - } else { - m.modifiersType = c.unknownType - } + return c.instantiateType(c.getTypeFromTypeNode(c.getConstraintDeclarationForMappedType(t).Type()), m.mapper) } - } - return m.modifiersType + // Otherwise, get the declared constraint type, and if the constraint type is a type parameter, + // get the constraint of that type parameter. If the resulting type is an indexed type 'keyof T', + // the modifiers type is T. Otherwise, the modifiers type is unknown. + declaredType := memoTypeNode(c, m.declaration.AsNode(), (*Checker).getTypeFromMappedTypeNode) + constraint := c.getConstraintTypeFromMappedType(declaredType) + extendedConstraint := constraint + if constraint != nil && constraint.flags&TypeFlagsTypeParameter != 0 { + extendedConstraint = c.getConstraintOfTypeParameter(getNonDistributedTypeParameter(constraint)) + } + if extendedConstraint != nil && extendedConstraint.flags&TypeFlagsIndex != 0 { + return c.instantiateType(extendedConstraint.AsIndexType().target, m.mapper) + } + return c.unknownType + }) } func (c *Checker) extractTypesOfKind(t *Type, kind TypeFlags) *Type { @@ -29017,15 +31678,26 @@ func (c *Checker) getRegularTypeOfObjectLiteral(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindRegularObjectLiteral, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) resolved := c.resolveStructuredTypeMembers(t) members := c.transformTypeOfMembers(t, c.getRegularTypeOfObjectLiteral) - regular := c.newAnonymousType(t.symbol, members, resolved.CallSignatures(), resolved.ConstructSignatures(), resolved.getIndexInfos()) - regular.flags = resolved.flags - regular.objectFlags |= resolved.objectFlags & ^ObjectFlagsFreshLiteral - c.cachedTypes[key] = regular + create := func() *Type { + regular := c.newAnonymousType(t.symbol, members, resolved.CallSignatures(), resolved.ConstructSignatures(), resolved.getIndexInfos()) + regular.flags = resolved.flags + regular.objectFlags |= resolved.objectFlags & ^ObjectFlagsFreshLiteral + return regular + } + var regular *Type + if len(resolved.CallSignatures()) == 0 && len(resolved.ConstructSignatures()) == 0 && resolved.flags == TypeFlagsObject { + regular = c.internObjectType(t.symbol, ObjectFlagsAnonymous|resolved.objectFlags&^ObjectFlagsFreshLiteral, members, resolved.getIndexInfos(), create) + } else { + regular = create() + } + c.cachedTypes.set(c, key, regular) + c.endMemo() return regular } @@ -29035,7 +31707,7 @@ func (c *Checker) transformTypeOfMembers(t *Type, f func(propertyType *Type) *Ty original := c.getTypeOfSymbol(property) updated := f(original) if updated != original { - property = c.createSymbolWithType(property, updated) + property = c.getSymbolWithType(property, updated) } members.Set(property.Name(), property) } @@ -29051,6 +31723,11 @@ func (c *Checker) markLinkedReferences(location *ast.Node, hint ReferenceHint, p // except for properties (which can be decorated). return } + if location.Flags&ast.NodeFlagsJSDoc != 0 { + // Neither are names in JSDoc, which only an editor resolves as + // expressions, such as the name of a link. + return + } switch hint { case ReferenceHintIdentifier: c.markIdentifierAliasReferenced(location) @@ -29432,6 +32109,52 @@ func (c *Checker) checkExternalEmitHelpers(location *ast.Node, helpers ExternalE if !ast.IsEffectiveExternalModule(sourceFile, c.compilerOptions) || location.Flags&ast.NodeFlagsAmbient != 0 { return } + if !c.checking { + c.recordEffect(func(c *Checker) { c.checkExternalEmitHelpers(location, helpers) }) + return + } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.checkExternalEmitHelpers(location, helpers) }) + return + } + links := c.sourceFileLinks.Get(sourceFile) + if links.typeChecked { + // Checking the helpers computes, so it waits for the end of the check + // in progress, outside the computations requesting them, whether + // checking or a query requested them. + c.addDeferredDiagnostic(func(c *Checker) { c.checkExternalEmitHelpersAt(sourceFile, location, helpers) }) + return + } + links.externalHelperRequests = append(links.externalHelperRequests, externalHelperRequest{location, helpers}) +} + +type externalHelperRequest struct { + location *ast.Node + helpers ExternalEmitHelpers +} + +// checkExternalHelperRequests checks the helpers requested by checking +// sourceFile. Errors are reported once per file, at the first location +// requesting a helper in the file, rather than the first location checked, +// since the order in which checking requests helpers depends on what was +// computed before. +func (c *Checker) checkExternalHelperRequests(sourceFile *ast.SourceFile) { + links := c.sourceFileLinks.Get(sourceFile) + requests := links.externalHelperRequests + links.externalHelperRequests = nil + slices.SortStableFunc(requests, func(a, b externalHelperRequest) int { + return cmp.Or( + cmp.Compare(a.location.Pos(), b.location.Pos()), + cmp.Compare(b.location.End(), a.location.End()), + cmp.Compare(a.location.Kind, b.location.Kind), + ) + }) + for _, r := range requests { + c.checkExternalEmitHelpersAt(sourceFile, r.location, r.helpers) + } +} + +func (c *Checker) checkExternalEmitHelpersAt(sourceFile *ast.SourceFile, location *ast.Node, helpers ExternalEmitHelpers) { helpersModule := c.resolveHelpersModule(sourceFile, location) if helpersModule == c.unknownSymbol { return @@ -29655,8 +32378,16 @@ func (c *Checker) getEntityNameForDecoratorMetadataFromTypeList(typeNodes []*ast } func (c *Checker) markAliasReferenced(symbol *ast.Symbol, location *ast.Node) { + if c.isAliasReferencedAt(symbol, location) { + c.markAliasSymbolAsReferenced(symbol) + } +} + +// isAliasReferencedAt reports whether a reference to symbol at location +// references it as an alias, so that the alias cannot be elided. +func (c *Checker) isAliasReferencedAt(symbol *ast.Symbol, location *ast.Node) bool { if !c.canCollectSymbolAliasAccessibilityData { - return + return false } if ast.IsNonLocalAlias(symbol, ast.SymbolFlagsValue /*excludes*/) && !IsInTypeQuery(location) { target := c.resolveAlias(symbol) @@ -29664,37 +32395,57 @@ func (c *Checker) markAliasReferenced(symbol *ast.Symbol, location *ast.Node) { // An alias resolving to a const enum cannot be elided if (1) 'isolatedModules' is enabled // (because the const enum value will not be inlined), or if (2) the alias is an export // of a const enum declaration that will be preserved. - if c.compilerOptions.GetIsolatedModules() || + return c.compilerOptions.GetIsolatedModules() || c.compilerOptions.ShouldPreserveConstEnums() && isExportOrExportExpression(location) || - !isConstEnumOrConstEnumOnlyModule(c.getExportSymbolOfValueSymbolIfExported(target)) { - c.markAliasSymbolAsReferenced(symbol) - } + !isConstEnumOrConstEnumOnlyModule(c.getExportSymbolOfValueSymbolIfExported(target)) } } + return false } // When an alias symbol is referenced, we need to mark the entity it references as referenced and in turn repeat that until -// we reach a non-alias or an exported entity (which is always considered referenced). We do this by checking the target of -// the alias as an expression (which recursively takes us back here if the target references another alias). +// we reach a non-alias or an exported entity (which is always considered referenced). Following the aliases computes, so +// they are followed here whether checking or a query reaches this; only marking them waits for checking. func (c *Checker) markAliasSymbolAsReferenced(symbol *ast.Symbol) { - links := c.aliasSymbolLinks.Get(symbol) - if !links.referenced { - links.referenced = true - node := c.getDeclarationOfAliasSymbol(symbol) - if node == nil { - panic("Unexpected nil in markAliasSymbolAsReferenced") - } - // We defer checking of the reference of an `import =` until the import itself is referenced, - // This way a chain of imports can be elided if ultimately the final input is only used in a type - // position. - if ast.IsImportEqualsDeclaration(node) && node.AsImportEqualsDeclaration().ModuleReference.Kind != ast.KindExternalModuleReference { - if c.getSymbolFlags(c.resolveSymbol(symbol))&ast.SymbolFlagsValue != 0 { - // import foo = - left := ast.GetFirstIdentifier(node.AsImportEqualsDeclaration().ModuleReference) - c.markIdentifierAliasReferenced(left) + var aliases []*ast.Symbol + for symbol != nil && !slices.Contains(aliases, symbol) { + aliases = append(aliases, symbol) + symbol = c.getAliasReferencedByAlias(symbol) + } + c.markAliasesReferenced(aliases) +} + +func (c *Checker) markAliasesReferenced(aliases []*ast.Symbol) { + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.markAliasesReferenced(aliases) }) + return + } + for _, alias := range aliases { + c.aliasSymbolLinks.Get(alias).referenced = true + } +} + +// getAliasReferencedByAlias returns the alias that referencing the alias +// symbol references in turn, if any. We defer checking of the reference of +// an `import =` until the import itself is referenced, this way a chain of +// imports can be elided if ultimately the final input is only used in a +// type position. Following it reports nothing; checking the declaration +// reports what is wrong with its reference. +func (c *Checker) getAliasReferencedByAlias(symbol *ast.Symbol) *ast.Symbol { + node := c.getDeclarationOfAliasSymbol(symbol) + if node == nil { + panic("Unexpected nil in markAliasSymbolAsReferenced") + } + if ast.IsImportEqualsDeclaration(node) && node.AsImportEqualsDeclaration().ModuleReference.Kind != ast.KindExternalModuleReference { + if c.getSymbolFlags(c.resolveSymbol(symbol))&ast.SymbolFlagsValue != 0 { + // import foo = + left := ast.GetFirstIdentifier(node.AsImportEqualsDeclaration().ModuleReference) + if target := c.resolveName(left, left.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, true /*isUse*/, false /*excludeGlobals*/); target != nil && c.isAliasReferencedAt(target, left) { + return target } } } + return nil } func (c *Checker) markExportAsReferenced(node *ast.Node /*ImportEqualsDeclaration | ExportSpecifier*/) { @@ -29790,13 +32541,29 @@ func (c *Checker) getPromisedTypeOfPromiseEx(t *Type, errorNode *ast.Node, thisT return nil } key := CachedTypeKey{kind: CachedTypeKindPromisedTypeOfPromise, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + if errorNode != nil { + // Errors belong to errorNode; see getIterationTypesOfIterable. Only + // a missing result reports any, so a result is shared all the same. + if result := c.getPromisedTypeOfPromiseEx(t, nil /*errorNode*/, thisTypeForErrorOut); result != nil { + return result + } + return c.getPromisedTypeOfPromiseWorker(t, errorNode, thisTypeForErrorOut) + } + c.cachedTypes.begin(c, key) + defer c.endMemo() + result := c.getPromisedTypeOfPromiseWorker(t, nil /*errorNode*/, thisTypeForErrorOut) + if result != nil { + c.cachedTypes.set(c, key, result) + } + return result +} + +func (c *Checker) getPromisedTypeOfPromiseWorker(t *Type, errorNode *ast.Node, thisTypeForErrorOut **Type) *Type { if c.isReferenceToType(t, c.getGlobalPromiseType()) { - result := c.getTypeArguments(t)[0] - c.cachedTypes[key] = result - return result + return c.getTypeArguments(t)[0] } // primitives with a `{ then() }` won't be unwrapped/adopted. if c.allTypesAssignableToKind(c.getBaseConstraintOrType(t), TypeFlagsPrimitive|TypeFlagsNever) { @@ -29848,9 +32615,7 @@ func (c *Checker) getPromisedTypeOfPromiseEx(t *Type, errorNode *ast.Node, thisT } return nil } - result := c.getUnionTypeEx(core.Map(onfulfilledParameterSignatures, c.getTypeOfFirstParameterOfSignature), UnionReductionSubtype, nil, nil) - c.cachedTypes[key] = result - return result + return c.getUnionTypeEx(core.Map(onfulfilledParameterSignatures, c.getTypeOfFirstParameterOfSignature), UnionReductionSubtype, nil, nil) } func (c *Checker) getTypeOfFirstParameterOfSignature(signature *Signature) *Type { @@ -30057,7 +32822,7 @@ func (c *Checker) getTemplateLiteralType(texts []string, types []*Type) *Type { } if !addSpans(texts, types) { if tooLarge { - c.error(c.currentNode, diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) + c.errorAtCurrentNode(diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) return c.errorType } return c.stringType @@ -30076,10 +32841,10 @@ func (c *Checker) getTemplateLiteralType(texts []string, types []*Type) *Type { } } key := getTemplateTypeKey(newTexts, newTypes) - t := c.templateLiteralTypes[key] + t, _ := c.templateLiteralTypes.get(key) if t == nil { t = c.newTemplateLiteralType(newTexts, newTypes) - c.templateLiteralTypes[key] = t + c.templateLiteralTypes.intern(key, t) } return t } @@ -30149,10 +32914,10 @@ func (c *Checker) applyTemplateStringMapping(symbol *ast.Symbol, texts []string, func (c *Checker) getStringMappingTypeForGenericType(symbol *ast.Symbol, t *Type) *Type { key := StringMappingKey{s: symbol, t: t} - result := c.stringMappingTypes[key] + result, _ := c.stringMappingTypes.get(key) if result == nil { result = c.newStringMappingType(symbol, t) - c.stringMappingTypes[key] = result + c.stringMappingTypes.intern(key, result) } return result } @@ -30342,8 +33107,7 @@ func (c *Checker) getContextuallyTypedParameterType(parameter *ast.Node) *Type { return c.getSpreadArgumentType(args, indexOfParameter, len(args), c.anyType, nil /*context*/, CheckModeNormal) } links := c.signatureLinks.Get(iife) - cached := links.resolvedSignature - links.resolvedSignature = c.anySignature + cached := links.resolvedSignature.swap(c.anySignature) var t *Type switch { case indexOfParameter < len(args): @@ -30353,7 +33117,7 @@ func (c *Checker) getContextuallyTypedParameterType(parameter *ast.Node) *Type { default: t = c.undefinedWideningType } - links.resolvedSignature = cached + links.resolvedSignature.swap(cached) return t } contextualSignature := c.getContextualSignature(fn) @@ -30547,6 +33311,13 @@ func (c *Checker) getContextualReturnType(functionDecl *ast.Node, contextFlags C // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature // and that call signature is non-generic, return statements are contextually typed by the return type of the signature signature := c.getContextualSignatureForFunctionLikeDeclaration(functionDecl) + // A function whose own signature is its contextual signature cannot + // contextually type its returns while their type is being inferred, even + // when that started before the resolution of an enclosing call, which + // hides it from isResolvingReturnTypeOfSignature. + if signature != nil && signature.declaration == functionDecl && c.resolvingAnywhereIndex(signature, TypeSystemPropertyNameResolvedReturnType) >= 0 { + signature = nil + } if signature != nil && !c.isResolvingReturnTypeOfSignature(signature) { returnType := c.getReturnTypeOfSignature(signature) functionFlags := ast.GetFunctionFlags(functionDecl) @@ -30656,11 +33427,20 @@ func (c *Checker) getContextualTypeForArgumentAtIndex(callTarget *ast.Node, argI } } // If we're already in the process of resolving the given signature, don't resolve again as - // that could cause infinite recursion. Instead, return anySignature. + // that could cause infinite recursion. Instead, use what the resolution has resolved so far: + // the signature a resolution of the call re-entering it resolved, or anySignature. var signature *Signature - if c.signatureLinks.Get(callTarget).resolvedSignature == c.resolvingSignature { - signature = c.resolvingSignature - } else { + if links := c.signatureLinks.Get(callTarget); c.isSignatureResolutionVisible(links) { + signature = links.resolvedSignature.inProgress(c) + } + if signature == c.resolvingSignature { + // The marker is the incomplete result of the call, so what is + // derived from it, such as implicit any errors for the parameters of + // a callback, is dropped if it is discarded. + if i := c.resolvingAnywhereIndex(callTarget, TypeSystemPropertyNameCallResolution); i >= 0 { + c.markReadIncomplete(i) + } + } else if signature == nil { signature = c.getResolvedSignature(callTarget, nil, CheckModeNormal) } if ast.IsJsxOpeningLikeElement(callTarget) && argIndex == 0 { @@ -30703,7 +33483,7 @@ func (c *Checker) getContextualTypeForBinaryOperand(node *ast.Node, contextFlags // by the type of the left operand, except for the special case of Javascript declarations of the form // `namespace.prop = namespace.prop || {}`. t := c.getContextualType(binary.AsNode(), contextFlags) - if node == binary.Right && (t == nil || c.patternForType[t] != nil) { + if node == binary.Right && (t == nil || c.patternForType.has(t)) { return c.getTypeOfExpression(binary.Left) } return t @@ -31037,15 +33817,16 @@ func (c *Checker) getDecoratorCallSignature(decorator *ast.Node) *Signature { func (c *Checker) getLegacyDecoratorCallSignature(decorator *ast.Node) *Signature { node := decorator.Parent links := c.signatureLinks.Get(node) - if links.decoratorSignature == nil { - links.decoratorSignature = c.anySignature + if links.decoratorSignature.cached(c) == nil { + links.decoratorSignature.begin(c) + links.decoratorSignature.set(c, c.anySignature) switch node.Kind { case ast.KindClassDeclaration, ast.KindClassExpression: // For a class decorator, the `target` is the type of the class (e.g. the // "static" or "constructor" side of the class). targetType := c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)) targetParam := c.newParameter("target", targetType) - links.decoratorSignature = c.newCallSignature(nil, nil, []*ast.Symbol{targetParam}, c.getUnionType([]*Type{targetType, c.voidType})) + links.decoratorSignature.set(c, c.newCallSignature(nil, nil, []*ast.Symbol{targetParam}, c.getUnionType([]*Type{targetType, c.voidType}))) case ast.KindParameter: if !ast.IsConstructorDeclaration(node.Parent) && !(ast.IsMethodDeclaration(node.Parent) || ast.IsSetAccessorDeclaration(node.Parent) && ast.IsClassLike(node.Parent.Parent)) { break @@ -31070,7 +33851,7 @@ func (c *Checker) getLegacyDecoratorCallSignature(decorator *ast.Node) *Signatur targetParam := c.newParameter("target", targetType) keyParam := c.newParameter("propertyKey", keyType) indexParam := c.newParameter("parameterIndex", indexType) - links.decoratorSignature = c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam, indexParam}, c.voidType) + links.decoratorSignature.set(c, c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam, indexParam}, c.voidType)) case ast.KindMethodDeclaration, ast.KindGetAccessor, ast.KindSetAccessor, ast.KindPropertyDeclaration: if !ast.IsClassLike(node.Parent) { break @@ -31089,16 +33870,17 @@ func (c *Checker) getLegacyDecoratorCallSignature(decorator *ast.Node) *Signatur if hasPropDesc { descriptorType := c.newTypedPropertyDescriptorType(c.getTypeOfNode(node)) descriptorParam := c.newParameter("descriptor", descriptorType) - links.decoratorSignature = c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam, descriptorParam}, c.getUnionType([]*Type{returnType, c.voidType})) + links.decoratorSignature.set(c, c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam, descriptorParam}, c.getUnionType([]*Type{returnType, c.voidType}))) } else { - links.decoratorSignature = c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam}, c.getUnionType([]*Type{returnType, c.voidType})) + links.decoratorSignature.set(c, c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam}, c.getUnionType([]*Type{returnType, c.voidType}))) } } + c.endMemo() } - if links.decoratorSignature == c.anySignature { + if links.decoratorSignature.cached(c) == c.anySignature { return nil } - return links.decoratorSignature + return links.decoratorSignature.cached(c) } func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { @@ -31184,15 +33966,16 @@ func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { // `undefined` then the "output type" is the "input type"). node := decorator.Parent links := c.signatureLinks.Get(node) - if links.decoratorSignature == nil { - links.decoratorSignature = c.anySignature + if links.decoratorSignature.cached(c) == nil { + links.decoratorSignature.begin(c) + links.decoratorSignature.set(c, c.anySignature) switch node.Kind { case ast.KindClassDeclaration, ast.KindClassExpression: // Class decorators have a `context` of `ClassDecoratorContext`, where the `Class` type // argument will be the "final type" of the class after all decorators are applied. targetType := c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)) contextType := c.newClassDecoratorContextType(targetType) - links.decoratorSignature = c.newESDecoratorCallSignature(targetType, contextType, targetType) + links.decoratorSignature.set(c, c.newESDecoratorCallSignature(targetType, contextType, targetType)) case ast.KindMethodDeclaration, ast.KindGetAccessor, ast.KindSetAccessor: if !ast.IsClassLike(node.Parent) { break @@ -31233,7 +34016,7 @@ func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { targetType = valueType } contextType := c.newClassMemberDecoratorContextTypeForNode(node, thisType, valueType) - links.decoratorSignature = c.newESDecoratorCallSignature(targetType, contextType, targetType) + links.decoratorSignature.set(c, c.newESDecoratorCallSignature(targetType, contextType, targetType)) case ast.KindPropertyDeclaration: if !ast.IsClassLike(node.Parent) { break @@ -31270,13 +34053,14 @@ func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { returnType = c.newClassFieldDecoratorInitializerMutatorType(thisType, valueType) } contextType := c.newClassMemberDecoratorContextTypeForNode(node, thisType, valueType) - links.decoratorSignature = c.newESDecoratorCallSignature(targetType, contextType, returnType) + links.decoratorSignature.set(c, c.newESDecoratorCallSignature(targetType, contextType, returnType)) } + c.endMemo() } - if links.decoratorSignature == c.anySignature { + if links.decoratorSignature.cached(c) == c.anySignature { return nil } - return links.decoratorSignature + return links.decoratorSignature.cached(c) } func (c *Checker) newClassDecoratorContextType(classType *Type) *Type { @@ -31312,7 +34096,7 @@ func (c *Checker) getClassMemberDecoratorContextOverrideType(nameType *Type, isP core.IfElse(isStatic, CachedTypeKindDecoratorContextStatic, CachedTypeKindDecoratorContext), ) key := CachedTypeKey{kind: kind, typeId: nameType.id} - if overrideType := c.cachedTypes[key]; overrideType != nil { + if overrideType, _ := c.cachedTypes.cached(c, key); overrideType != nil { return overrideType } members := ast.NewSymbolTable() @@ -31320,7 +34104,7 @@ func (c *Checker) getClassMemberDecoratorContextOverrideType(nameType *Type, isP members.Set("private", c.newProperty("private", core.IfElse(isPrivate, c.trueType, c.falseType))) members.Set("static", c.newProperty("static", core.IfElse(isStatic, c.trueType, c.falseType))) overrideType := c.newAnonymousType(nil, members, nil, nil, nil) - c.cachedTypes[key] = overrideType + c.cachedTypes.intern(key, overrideType) return overrideType } @@ -31486,7 +34270,7 @@ func (c *Checker) getIndexedMappedTypeSubstitutedTypeOfContextualType(t *Type, n } constraint := c.getConstraintTypeFromMappedType(t) // special case for conditional types pretending to be negated types - if t.AsMappedType().nameType != nil && c.isExcludedMappedPropertyName(t.AsMappedType().nameType, propertyNameType) || c.isExcludedMappedPropertyName(constraint, propertyNameType) { + if mappedNameType := c.getNameTypeFromMappedType(t); mappedNameType != nil && c.isExcludedMappedPropertyName(mappedNameType, propertyNameType) || c.isExcludedMappedPropertyName(constraint, propertyNameType) { return nil } constraintOfConstraint := c.getBaseConstraintOrType(constraint) @@ -31537,8 +34321,7 @@ func (c *Checker) getTypeFromIndexInfosOfContextualType(t *Type, name string, na func (c *Checker) isCircularMappedProperty(symbol *ast.Symbol) bool { if symbol.CheckFlags()&ast.CheckFlagsMapped != 0 { - links := c.valueSymbolLinks.Get(symbol) - return links.resolvedType == nil && c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameType) >= 0 + return c.isResolutionInProgress(symbol, TypeSystemPropertyNameType) } return false } @@ -31629,9 +34412,10 @@ func (d *ObjectLiteralDiscriminator) matches(index int, t *Type) bool { func (c *Checker) discriminateContextualTypeByObjectMembers(node *ast.Node, contextualType *Type) *Type { key := DiscriminatedContextualTypeKey{nodeId: ast.GetNodeId(node), typeId: contextualType.id} - if discriminated := c.discriminatedContextualTypes[key]; discriminated != nil { + if discriminated, _ := c.discriminatedContextualTypes.cached(c, key); discriminated != nil { return discriminated } + c.discriminatedContextualTypes.begin(c, key) discriminated := c.getMatchingUnionConstituentForObjectLiteral(contextualType, node) if discriminated == nil { discriminantProperties := core.Filter(node.Properties(), func(p *ast.Node) bool { @@ -31653,7 +34437,8 @@ func (c *Checker) discriminateContextualTypeByObjectMembers(node *ast.Node, cont discriminator := &ObjectLiteralDiscriminator{c: c, props: discriminantProperties, members: discriminantMembers} discriminated = c.discriminateTypeByDiscriminableItems(contextualType, discriminator) } - c.discriminatedContextualTypes[key] = discriminated + c.discriminatedContextualTypes.set(c, key, discriminated) + c.endMemo() return discriminated } @@ -31759,7 +34544,7 @@ func (c *Checker) popContextualType() { } func (c *Checker) findContextualNode(node *ast.Node, includeCaches bool) int { - for i, info := range c.contextualInfos { + for i, info := range slices.Backward(c.contextualInfos) { if node == info.node && (includeCaches || !info.isCache) { return i } @@ -32019,7 +34804,7 @@ func (c *Checker) isFunctionObjectType(t *Type) bool { // We do a quick check for a "bind" property before performing the more expensive subtype // check. This gives us a quicker out in the common case where an object type is not a function. resolved := c.resolveStructuredTypeMembers(t) - return len(resolved.getSignatures()) != 0 || resolved.getMember("bind") != nil && c.isTypeSubtypeOf(t, c.globalFunctionType) + return len(resolved.getSignatures()) != 0 || resolved.getMember(c, "bind") != nil && c.isTypeSubtypeOf(t, c.globalFunctionType) } func (c *Checker) getTypeWithFacts(t *Type, include TypeFacts) *Type { @@ -32152,32 +34937,53 @@ func (c *Checker) getAwaitedTypeNoAliasEx(t *Type, errorNode *ast.Node, diagnost } // If we've already cached an awaited type, return a possible `Awaited` for it. key := CachedTypeKey{kind: CachedTypeKindAwaitedType, typeId: t.id} - if awaitedType := c.cachedTypes[key]; awaitedType != nil { + if awaitedType, _ := c.cachedTypes.cached(c, key); awaitedType != nil { return awaitedType } + if errorNode != nil { + // Errors belong to errorNode; see getIterationTypesOfIterable. Only a + // result computing which reports nothing is cached, so it is shared + // all the same. + if c.getAwaitedTypeNoAliasEx(t, nil /*errorNode*/, nil /*diagnosticMessage*/) != nil { + if awaitedType, _ := c.cachedTypes.cached(c, key); awaitedType != nil { + return awaitedType + } + } + return c.getAwaitedTypeNoAliasWorker(t, errorNode, diagnosticMessage, args...) + } + c.cachedTypes.begin(c, key) + defer c.endMemo() + errors := c.awaitedTypeErrors + awaitedType := c.getAwaitedTypeNoAliasWorker(t, nil /*errorNode*/, nil /*diagnosticMessage*/) + if awaitedType != nil && c.awaitedTypeErrors == errors { + c.cachedTypes.set(c, key, awaitedType) + } + return awaitedType +} + +func (c *Checker) getAwaitedTypeNoAliasWorker(t *Type, errorNode *ast.Node, diagnosticMessage *diagnostics.Message, args ...any) *Type { // For a union, get a union of the awaited types of each constituent. if t.flags&TypeFlagsUnion != 0 { - if slices.Contains(c.awaitedTypeStack, t) { + if c.isAwaitingType(t) { + c.awaitedTypeErrors++ if errorNode != nil { c.error(errorNode, diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method) } return nil } - c.awaitedTypeStack = append(c.awaitedTypeStack, t) + c.pushAwaitingType(t) mapped := c.mapType(t, func(t *Type) *Type { return c.getAwaitedTypeNoAliasEx(t, errorNode, diagnosticMessage, args...) }) - c.awaitedTypeStack = c.awaitedTypeStack[:len(c.awaitedTypeStack)-1] - c.cachedTypes[key] = mapped + c.popTypeResolution() return mapped } // If `type` is generic and should be wrapped in `Awaited`, return it. if c.isAwaitedTypeNeeded(t) { - c.cachedTypes[key] = t return t } var thisTypeForError *Type promisedType := c.getPromisedTypeOfPromiseEx(t, nil /*errorNode*/, &thisTypeForError) if promisedType != nil { - if t == promisedType || slices.Contains(c.awaitedTypeStack, promisedType) { + if t == promisedType || c.isAwaitingType(promisedType) { // Verify that we don't have a bad actor in the form of a promise whose // promised type is the same as the promise type, or a mutually recursive // promise. If so, we return undefined as we cannot guess the shape. If this @@ -32211,6 +35017,7 @@ func (c *Checker) getAwaitedTypeNoAliasEx(t *Type, errorNode *ast.Node, diagnost // onrejected: (error: any) => any): BadPromiseA; // } // + c.awaitedTypeErrors++ if errorNode != nil { c.error(errorNode, diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method) } @@ -32218,13 +35025,9 @@ func (c *Checker) getAwaitedTypeNoAliasEx(t *Type, errorNode *ast.Node, diagnost } // Keep track of the type we're about to unwrap to avoid bad recursive promise types. // See the comments above for more information. - c.awaitedTypeStack = append(c.awaitedTypeStack, t) + c.pushAwaitingType(t) awaitedType := c.getAwaitedTypeNoAliasEx(promisedType, errorNode, diagnosticMessage, args...) - c.awaitedTypeStack = c.awaitedTypeStack[:len(c.awaitedTypeStack)-1] - if awaitedType == nil { - return nil - } - c.cachedTypes[key] = awaitedType + c.popTypeResolution() return awaitedType } // The type was not a promise, so it could not be unwrapped any further. @@ -32243,6 +35046,7 @@ func (c *Checker) getAwaitedTypeNoAliasEx(t *Type, errorNode *ast.Node, diagnost // function, they would need to wrap it in some other value. If they want it to // be treated as a promise, they can cast to . if c.isThenableType(t) { + c.awaitedTypeErrors++ if errorNode != nil { var diagnostic *ast.Diagnostic if thisTypeForError != nil { @@ -32252,10 +35056,21 @@ func (c *Checker) getAwaitedTypeNoAliasEx(t *Type, errorNode *ast.Node, diagnost } return nil } - c.cachedTypes[key] = t return t } +// pushAwaitingType records that the awaited type of t is being computed, until +// the matching popTypeResolution. +func (c *Checker) pushAwaitingType(t *Type) { + c.beginTypeResolution(t, TypeSystemPropertyNameAwaitedType, nil) +} + +// isAwaitingType reports whether the awaited type of t is being computed; +// see isResolvingAnywhere. +func (c *Checker) isAwaitingType(t *Type) bool { + return c.isResolvingAnywhere(t, TypeSystemPropertyNameAwaitedType) +} + func (c *Checker) isAwaitedTypeInstantiation(t *Type) bool { if t.flags&TypeFlagsConditional != 0 { awaitedSymbol := c.getGlobalAwaitedSymbolOrNil() @@ -32515,7 +35330,7 @@ func (c *Checker) getSymbolAtLocation(node *ast.Node, ignoreErrors bool) *ast.Sy // member should more exactly be the kind of (declarationless) symbol we want. // (See #44364 and #45031 for relevant implementation PRs) if metaProp.KeywordToken == ast.KindImportKeyword && node.Text() == "meta" { - return c.getGlobalImportMetaExpressionType().AsObjectType().getMember("meta") + return c.getGlobalImportMetaExpressionType().AsObjectType().getMember(c, "meta") } // no other meta properties are valid syntax, thus no others should have symbols return nil @@ -32549,7 +35364,7 @@ func (c *Checker) getSymbolAtLocation(node *ast.Node, ignoreErrors bool) *ast.Sy } fallthrough case ast.KindThisType: - return c.getTypeFromThisTypeNode(node).symbol + return memoTypeNode(c, node, (*Checker).getTypeFromThisTypeNode).symbol case ast.KindSuperKeyword: return c.checkExpression(node).symbol case ast.KindConstructorKeyword: @@ -32682,8 +35497,7 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast if ast.IsEntityName(name) { possibleImportNode := isImportTypeQualifierPart(name) if possibleImportNode != nil { - c.getTypeFromTypeNode(possibleImportNode) - sym := c.getResolvedSymbolOrNil(name) + sym := c.getSymbolOfTypeNodePart(possibleImportNode, name) return core.IfElse(sym == c.unknownSymbol, nil, sym) } } @@ -32747,25 +35561,23 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast } else if ast.IsPrivateIdentifier(name) { return c.getSymbolForPrivateIdentifierExpression(name) } else if ast.IsPropertyAccessExpression(name) || ast.IsQualifiedName(name) { - links := c.symbolNodeLinks.Get(name) - if links.resolvedSymbol != nil { - return links.resolvedSymbol - } - if ast.IsPropertyAccessExpression(name) { - c.checkPropertyAccessExpression(name, CheckModeNormal, false /*writeOnly*/) - if links.resolvedSymbol == nil && !ast.IsPrivateIdentifier(name.Name()) { - links.resolvedSymbol = c.getApplicableIndexSymbol( - c.checkExpressionCached(name.Expression()), - c.getLiteralTypeFromPropertyName(name.Name()), - ) - } - } else { - c.checkQualifiedName(name, CheckModeNormal) + // The symbol is read back from links after checking, before a query + // finishing would discard it. + query, ok := c.enterQuery() + defer c.exitQuery(query, ok) + symbol := c.getSymbolOfExpression(name) + if symbol == nil && ast.IsPropertyAccessExpression(name) && !ast.IsPrivateIdentifier(name.Name()) { + // Not cached in links, where checking would observe it as the + // property the access resolved to. + return c.getApplicableIndexSymbol( + c.checkExpressionCached(name.Expression()), + c.getLiteralTypeFromPropertyName(name.Name()), + ) } - if links.resolvedSymbol == nil && isJSDoc && ast.IsQualifiedName(name) { + if symbol == nil && isJSDoc && ast.IsQualifiedName(name) { return c.resolveJSDocMemberName(name) } - return links.resolvedSymbol + return symbol } } else if ast.IsEntityName(name) && isTypeReferenceIdentifier(name) { meaning := core.IfElse(name.Parent.Kind == ast.KindTypeReference, ast.SymbolFlagsType, ast.SymbolFlagsNamespace) @@ -32982,7 +35794,7 @@ func (c *Checker) getApplicableIndexSymbol(t *Type, keyType *Type) *ast.Symbol { symbol.SetValueDeclaration(declarations[0]) symbol.SetParent(t.symbol) links := c.valueSymbolLinks.Get(symbol) - links.resolvedType = info.valueType + links.resolvedType.setIdentity(c, info.valueType) info.indexSymbol = symbol } } @@ -33003,9 +35815,10 @@ func (c *Checker) containsArgumentsReference(node *ast.Node) bool { return false } - if containsArguments, ok := c.cachedArgumentsReferenced[node]; ok { + if containsArguments, ok := c.cachedArgumentsReferenced.cached(c, node); ok { return containsArguments } + c.cachedArgumentsReferenced.begin(c, node) var visit func(node *ast.Node) bool visit = func(node *ast.Node) bool { @@ -33031,7 +35844,8 @@ func (c *Checker) containsArgumentsReference(node *ast.Node) bool { } containsArguments := visit(node.Body()) - c.cachedArgumentsReferenced[node] = containsArguments + c.cachedArgumentsReferenced.set(c, node, containsArguments) + c.endMemo() return containsArguments } diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index f5b766607c5f7..0a31eaa06c8f9 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -2,7 +2,11 @@ package checker_test import ( "fmt" + goast "go/ast" + "go/parser" + "go/token" "path/filepath" + "slices" "strings" "testing" @@ -182,6 +186,47 @@ func BenchmarkCheckFreshProgram(b *testing.B) { } } +func TestQueriesDoNotMoveErrorsAtCurrentNode(t *testing.T) { + t.Parallel() + + // Asking for the symbol of t.x computes T<"x"> at no node, reporting + // an excessive depth there. Asking for the type of tx then reuses it at + // t.x, so checking reports the error at t.x and not at tx. + content := `type T = { + x: T[K]; + y: number; +}; + +declare let t: T<"x">; +let tx = t.x; +` + diagnostics := func(query bool) []string { + fs := bundled.WrapFS(vfstest.FromMap(map[string]string{ + "/foo.ts": content, + "/tsconfig.json": `{"files": ["foo.ts"]}`, + }, tspath.CaseInsensitive)) + host := compiler.NewCompilerHost(fs, bundled.LibPath(), nil, nil, nil) + parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile("/tsconfig.json", &core.CompilerOptions{}, nil, tsoptions.NewDefaultParseConfigHost(fs), nil) + assert.Equal(t, len(errors), 0) + p, err := compiler.NewProgram(t.Context(), compiler.ProgramOptions{Config: parsed, Host: host}) + assert.NilError(t, err) + file := p.GetSourceFile("/foo.ts") + if query { + c, done := p.GetTypeCheckerForFile(t.Context(), file) + decl := file.Statements.Nodes[2].AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes[0] + c.GetSymbolAtLocation(decl.Initializer().Name()) + c.GetTypeAtLocation(decl.Name()) + done() + } + var result []string + for _, d := range p.GetSemanticDiagnostics(t.Context(), file) { + result = append(result, fmt.Sprintf("%d: TS%d", d.Pos(), d.Code())) + } + return result + } + assert.DeepEqual(t, diagnostics(true), diagnostics(false)) +} + func TestTypeAllocationAcrossCheckerGrowth(t *testing.T) { t.Parallel() var content strings.Builder @@ -214,3 +259,570 @@ export type Initial = Box<"first">; assert.Equal(t, c.TypeToString(initial), "Initial") assert.Equal(t, len(c.GetDiagnostics(t.Context(), file)), 0) } + +// Memoized results must only be accessed through memo methods, which account +// for the effects of computing them. +func TestMemoValueOnlyAccessedThroughMethods(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + for _, name := range files { + if name == "memo.go" || strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + goast.Inspect(file, func(n goast.Node) bool { + if sel, ok := n.(*goast.SelectorExpr); ok && sel.Sel.Name == "memoValue" { + t.Errorf("%s: memo value accessed directly; use get or set", fset.Position(sel.Pos())) + } + return true + }) + } +} + +// Mutable cached state must live in memos, which account for the effects of +// computing it, or in internMaps, whose entries have none. Other fields must +// be listed in unmemoizedCacheFields with the reason they need not be. +func TestCachedStateIsMemoized(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + seen := make(map[string]bool) + // The state of computations in progress, which Checker.AssertAtRest checks. + progress := make(map[string]bool) + var parsed []*goast.File + // Entries interned by pointer own the results cached in them. + interned := make(map[string]bool) + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + parsed = append(parsed, file) + goast.Inspect(file, func(n goast.Node) bool { + if vs, ok := n.(*goast.ValueSpec); ok && len(vs.Names) == 1 && vs.Names[0].Name == "checkerProgressFields" { + for _, elt := range vs.Values[0].(*goast.CompositeLit).Elts { + progress[strings.Trim(elt.(*goast.BasicLit).Value, `"`)] = true + } + } + if e, ok := n.(*goast.IndexListExpr); ok { + if ident, ok := e.X.(*goast.Ident); ok && ident.Name == "internMap" && len(e.Indices) == 2 { + if star, ok := e.Indices[1].(*goast.StarExpr); ok { + if elem, ok := star.X.(*goast.Ident); ok { + interned[elem.Name] = true + } + } + } + } + return true + }) + } + for _, file := range parsed { + name := filepath.Base(fset.File(file.Pos()).Name()) + goast.Inspect(file, func(n goast.Node) bool { + spec, ok := n.(*goast.TypeSpec) + if !ok { + return true + } + st, ok := spec.Type.(*goast.StructType) + isChecker := spec.Name.Name == "Checker" + if !ok || slices.Contains(notCacheOwners, spec.Name.Name) || name != "types.go" && !strings.HasSuffix(spec.Name.Name, "Links") && spec.Name.Name != "memoStore" && !isChecker && !interned[spec.Name.Name] { + return true + } + for _, field := range st.Fields.List { + if isMemoType(field.Type) { + continue + } + if isChecker && isCheckerCreated(field.Type) { + continue + } + for _, fieldName := range field.Names { + key := spec.Name.Name + "." + fieldName.Name + if isChecker && progress[fieldName.Name] { + if _, ok := unmemoizedCheckerFields[key]; ok { + t.Errorf("%s: %s is listed both in checkerProgressFields and in unmemoizedCheckerFields", fset.Position(fieldName.Pos()), key) + } + delete(progress, fieldName.Name) + continue + } + seen[key] = true + if isChecker { + if _, ok := unmemoizedCheckerFields[key]; !ok { + t.Errorf("%s: %s is not a memo; list it in checkerProgressFields or unmemoizedCheckerFields", fset.Position(fieldName.Pos()), key) + } + } else if _, ok := unmemoizedCacheFields[key]; !ok { + t.Errorf("%s: %s is not a memo; make it one or list it in unmemoizedCacheFields", fset.Position(fieldName.Pos()), key) + } + } + } + return false + }) + } + for key := range unmemoizedCacheFields { + if !seen[key] { + t.Errorf("unmemoizedCacheFields lists %s, which is not an unmemoized field", key) + } + } + for key := range unmemoizedCheckerFields { + if !seen[key] { + t.Errorf("unmemoizedCheckerFields lists %s, which is not an unmemoized field", key) + } + } + for name := range progress { + t.Errorf("checkerProgressFields lists %s, which is not an unmemoized field of Checker", name) + } +} + +// isCheckerCreated reports whether a field of Checker of type expr is +// created with the checker: a closure, or an allocator for the entities it +// creates. +func isCheckerCreated(expr goast.Expr) bool { + switch e := expr.(type) { + case *goast.IndexExpr: + expr = e.X + case *goast.IndexListExpr: + expr = e.X + } + switch e := expr.(type) { + case *goast.FuncType: + return true + case *goast.SelectorExpr: + return strings.HasSuffix(e.Sel.Name, "Arena") + case *goast.Ident: + return strings.HasSuffix(e.Name, "Arena") + } + return false +} + +func isMemoType(expr goast.Expr) bool { + if a, ok := expr.(*goast.ArrayType); ok { + expr = a.Elt + } + switch e := expr.(type) { + case *goast.IndexExpr: + expr = e.X + case *goast.IndexListExpr: + expr = e.X + } + ident, ok := expr.(*goast.Ident) + return ok && (strings.HasPrefix(ident.Name, "memo") || ident.Name == "internMap") +} + +const ( + unmemoizedImmutable = "Set when the store is created" + unmemoizedCheckerSetup = "Set when the checker is created" + unmemoizedScratch = "Reused buffer or free list, whose contents nothing reads before writing" + unmemoizedContainer = "Holds links, whose fields are checked separately" + unmemoizedCounter = "Allocation counter for IDs and statistics" + unmemoizedInterned = "Interned type whose creation has no effects" + unmemoizedProgram = "Derived from the program only; computing it has no effects" + unmemoizedMemoState = "State of the memos themselves" + unmemoizedChecking = "Written only by checks" + unmemoizedCreated = "Set when the entity owning the links is created" + unmemoizedSyntax = "Derived from syntax and options only; computing it has no effects" + unmemoizedGuarded = "Written only within the memoized computation it is part of" + unmemoizedEmit = "Emit resolver state, written only while resolving for emit" + unmemoizedMark = "Written only by checks and emit marking, and read only by emit" + unmemoizedNodeBuilder = "Node builder state, scoped to one node builder" + unmemoizedNodeFlags = "Each flag is memo-guarded, reporting-only, or set whenever a node is checked and read only by deferred diagnostics, after the whole file is checked" + unmemoizedFlagMemo = "Flag memo, accounted for like a memo under a key naming its entity and field" + unmemoizedEntityFlags = "Each flag is set when the entity is created, or is part of a flag memo" + unmemoizedDerived = "Derived only from fields set when the entity is created; computing it has no effects" + unmemoizedLoopFixpoint = "Fixed point of a loop, kept once complete; analyzing it again from another reference may differ" +) + +// notCacheOwners are the structs declared in types.go that are plain values +// rather than entities owning cached state. +var notCacheOwners = []string{"LanguageFeatureMinimumTargetMap", "accessibleChainCacheKey", "computedName", "TupleElementInfo", "MemberInfo", "RelationCacheSizes"} + +// unmemoizedCheckerFields lists the fields of Checker, other than those in +// checkerProgressFields, like unmemoizedCacheFields. +var unmemoizedCheckerFields = map[string]string{ + "Checker.awaitedTypeErrors": "Counter compared only within one computation", + "Checker.flowInvocationCount": "Counter compared only within one computation", + "Checker.resolutionSerials": unmemoizedCounter, + "Checker.instantiationCount": "Counts within a statement or outermost computation, and starts again for each; see \"Instantiation limits\"", + "Checker.wasCanceled": "Set when a check is canceled, after which the checker is not used", + "Checker.evaluate": unmemoizedCheckerSetup, + "Checker.factory": unmemoizedCheckerSetup, + "Checker.uniqueLiteralMapper": unmemoizedCheckerSetup, + "Checker.reportUnreliableMapper": unmemoizedCheckerSetup, + "Checker.reportUnmeasurableMapper": unmemoizedCheckerSetup, + "Checker.restrictiveMapper": unmemoizedCheckerSetup, + "Checker.permissiveMapper": unmemoizedCheckerSetup, + "Checker.syncIterationTypesResolver": unmemoizedCheckerSetup, + "Checker.asyncIterationTypesResolver": unmemoizedCheckerSetup, + "Checker.compareTypesAssignable": unmemoizedCheckerSetup, + "Checker.tracer": unmemoizedCheckerSetup, + "Checker.layoutMembers": unmemoizedScratch, + "Checker.layoutBaseIndices": unmemoizedScratch, + "Checker.freeTypeSets": unmemoizedScratch, + "Checker.freePropertyCounts": unmemoizedScratch, + "Checker.freeinferenceState": unmemoizedScratch, + "Checker.freeFlowState": unmemoizedScratch, + "Checker.freeRelater": unmemoizedScratch, + "Checker.flushBuf": unmemoizedScratch, + "Checker.resumeBuf": unmemoizedScratch, + "Checker.regExpScanner": unmemoizedScratch, + "Checker.typeToStringNodebuilder": unmemoizedScratch, + "Checker.lastGetCombinedNodeFlagsNode": unmemoizedSyntax, + "Checker.lastGetCombinedNodeFlagsResult": unmemoizedSyntax, + "Checker.lastGetCombinedModifierFlagsNode": unmemoizedSyntax, + "Checker.lastGetCombinedModifierFlagsResult": unmemoizedSyntax, + "Checker.lastLateBindableParent": "Derived from syntax and the merges made before checking", + "Checker.lastLateBindableKinds": "Derived from syntax and the merges made before checking", + "Checker.lastFlowNode": "Reused only when no memo observes the reachability it caches", + "Checker.lastFlowNodeReachable": "Reused only when no memo observes the reachability it caches", + "Checker.flowDepthFailures": "A walk from a node that fails within a depth budget fails within any smaller one, regardless of earlier walks", +} + +var unmemoizedCacheFields = map[string]string{ + "valueSymbolExtra.nameType": unmemoizedCreated, + "valueSymbolExtra.containingType": unmemoizedCreated, + "valueSymbolExtra.instantiatedFrom": unmemoizedCreated, + "TypeAlias.symbol": unmemoizedCreated, + "TypeAlias.typeArguments": unmemoizedCreated, + "Type.flags": unmemoizedCreated, + "Type.objectFlags": unmemoizedEntityFlags, + "Type.id": unmemoizedCounter, + "Type.kind": unmemoizedCreated, + "Type.generation": unmemoizedDerived, + "memoStore.tooDeepInstantiations": "Instantiations known to reach the limit on the instantiation stack, whichever order computes them; see \"Instantiation limits\"", + "Type.baseConstraintHeight": "Set with the resolved base constraint whose walk it describes; see \"Base constraint walks\"", + "Type.symbol": unmemoizedCreated, + "Type.alias": unmemoizedCreated, + "Type.checker": unmemoizedImmutable, + "IntrinsicType.intrinsicName": unmemoizedCreated, + "LiteralType.value": unmemoizedCreated, + "LiteralType.freshType": unmemoizedInterned, + "LiteralType.regularType": unmemoizedCreated, + "UniqueESSymbolType.name": unmemoizedCreated, + "StructuredType.members": unmemoizedFlagMemo, + "StructuredType.properties": unmemoizedFlagMemo, + "StructuredType.extra": unmemoizedFlagMemo, + "structuredTypeExtra.signatures": unmemoizedFlagMemo, + "structuredTypeExtra.callSignatureCount": unmemoizedFlagMemo, + "structuredTypeExtra.indexInfos": unmemoizedFlagMemo, + "structuredTypeExtra.objectTypeWithoutAbstractConstructSignatures": unmemoizedInterned, + "ObjectType.target": unmemoizedCreated, + "ObjectType.mapper": unmemoizedCreated, + "TypeReference.node": unmemoizedCreated, + "TypeReference.lazy": unmemoizedFlagMemo, + "LazyState.layout": unmemoizedCreated, + "LazyState.mapper": unmemoizedCreated, + "LazyState.baseTypes": unmemoizedCreated, + "LazyState.propertiesResolved": unmemoizedFlagMemo, + "MemberLayout.id": unmemoizedCounter, + "MemberLayout.baseIndices": unmemoizedCreated, + "MemberLayout.members": unmemoizedCreated, + "MemberLayout.layoutProperties": unmemoizedDerived, + "InterfaceType.allTypeParameters": unmemoizedCreated, + "InterfaceType.outerTypeParameterCount": unmemoizedCreated, + "InterfaceType.thisType": unmemoizedCreated, + "InterfaceType.baseTypesResolved": unmemoizedFlagMemo, + "InterfaceType.declaredMembersResolved": unmemoizedFlagMemo, + "InterfaceType.declaredMembers": unmemoizedFlagMemo, + "InterfaceType.declaredCallSignatures": unmemoizedFlagMemo, + "InterfaceType.declaredConstructSignatures": unmemoizedFlagMemo, + "InterfaceType.declaredIndexInfos": unmemoizedFlagMemo, + "TupleType.elementInfos": unmemoizedCreated, + "TupleType.minLength": unmemoizedCreated, + "TupleType.fixedLength": unmemoizedCreated, + "TupleType.combinedFlags": unmemoizedCreated, + "TupleType.readonly": unmemoizedCreated, + "InstantiationExpressionType.node": unmemoizedCreated, + "MappedType.declaration": unmemoizedCreated, + "ReverseMappedType.source": unmemoizedCreated, + "ReverseMappedType.mappedType": unmemoizedCreated, + "ReverseMappedType.constraintType": unmemoizedCreated, + "EvolvingArrayType.elementType": unmemoizedCreated, + "UnionOrIntersectionType.types": unmemoizedCreated, + "UnionType.regularType": unmemoizedInterned, + "UnionType.origin": unmemoizedCreated, + "UnionType.constituentMap": unmemoizedGuarded, + "TypeParameter.target": unmemoizedCreated, + "TypeParameter.mapper": unmemoizedCreated, + "TypeParameter.isThisType": unmemoizedCreated, + "TypeParameter.isDistributed": unmemoizedCreated, + "TypeParameter.distributedType": unmemoizedInterned, + "TypeParameter.origin": unmemoizedCreated, + "IndexType.target": unmemoizedCreated, + "IndexType.indexFlags": unmemoizedCreated, + "IndexedAccessType.objectType": unmemoizedCreated, + "IndexedAccessType.indexType": unmemoizedCreated, + "IndexedAccessType.accessFlags": unmemoizedCreated, + "TemplateLiteralType.texts": unmemoizedCreated, + "TemplateLiteralType.types": unmemoizedCreated, + "StringMappingType.target": unmemoizedCreated, + "SubstitutionType.baseType": unmemoizedCreated, + "SubstitutionType.constraint": unmemoizedCreated, + "ConditionalRoot.node": unmemoizedCreated, + "ConditionalRoot.checkType": unmemoizedCreated, + "ConditionalRoot.extendsType": unmemoizedCreated, + "ConditionalRoot.isDistributive": unmemoizedCreated, + "ConditionalRoot.inferTypeParameters": unmemoizedCreated, + "ConditionalRoot.outerTypeParameters": unmemoizedCreated, + "ConditionalRoot.alias": unmemoizedCreated, + "ConditionalType.restrictive": unmemoizedCreated, + "ConditionalType.root": unmemoizedCreated, + "ConditionalType.checkType": unmemoizedCreated, + "ConditionalType.extendsType": unmemoizedCreated, + "ConditionalType.mapper": unmemoizedCreated, + "ConditionalType.combinedMapper": unmemoizedCreated, + "Signature.id": unmemoizedCreated, + "Signature.flags": unmemoizedEntityFlags, + "Signature.minArgumentCount": unmemoizedCreated, + "Signature.declaration": unmemoizedCreated, + "Signature.parameters": unmemoizedCreated, + "Signature.target": unmemoizedCreated, + "Signature.mapper": unmemoizedCreated, + "Signature.extra": unmemoizedCreated, + "signatureExtra.typeParameters": unmemoizedCreated, + "signatureExtra.thisParameter": unmemoizedCreated, + "signatureExtra.resolvedTypePredicate": unmemoizedFlagMemo, + "signatureExtra.isolatedSignatureType": unmemoizedInterned, + "signatureExtra.composite": unmemoizedCreated, + "CompositeSignature.isUnion": unmemoizedCreated, + "CompositeSignature.signatures": unmemoizedCreated, + "TypePredicate.kind": unmemoizedCreated, + "TypePredicate.parameterIndex": unmemoizedCreated, + "TypePredicate.parameterName": unmemoizedCreated, + "TypePredicate.t": unmemoizedCreated, + "IndexInfo.keyType": unmemoizedCreated, + "IndexInfo.valueType": unmemoizedCreated, + "IndexInfo.isReadonly": unmemoizedCreated, + "IndexInfo.declaration": unmemoizedCreated, + "IndexInfo.indexSymbol": unmemoizedInterned, + "IndexInfo.components": unmemoizedCreated, + "memoStore.root": unmemoizedImmutable, + "memoStore.id": unmemoizedImmutable, + "memoStore.program": unmemoizedImmutable, + "memoStore.compilerOptions": unmemoizedImmutable, + "memoStore.files": unmemoizedImmutable, + "memoStore.fileIndexMap": unmemoizedImmutable, + "memoStore.languageVersion": unmemoizedImmutable, + "memoStore.moduleKind": unmemoizedImmutable, + "memoStore.moduleResolutionKind": unmemoizedImmutable, + "memoStore.legacyDecorators": unmemoizedImmutable, + "memoStore.emitStandardClassFields": unmemoizedImmutable, + "memoStore.strictNullChecks": unmemoizedImmutable, + "memoStore.strictFunctionTypes": unmemoizedImmutable, + "memoStore.strictBindCallApply": unmemoizedImmutable, + "memoStore.strictPropertyInitialization": unmemoizedImmutable, + "memoStore.strictBuiltinIteratorReturn": unmemoizedImmutable, + "memoStore.noImplicitAny": unmemoizedImmutable, + "memoStore.noImplicitThis": unmemoizedImmutable, + "memoStore.useUnknownInCatchVariables": unmemoizedImmutable, + "memoStore.exactOptionalPropertyTypes": unmemoizedImmutable, + "memoStore.canCollectSymbolAliasAccessibilityData": unmemoizedImmutable, + "memoStore.arrayVariances": unmemoizedImmutable, + "memoStore.globals": unmemoizedImmutable, + "memoStore.undefinedSymbol": unmemoizedImmutable, + "memoStore.argumentsSymbol": unmemoizedImmutable, + "memoStore.requireSymbol": unmemoizedImmutable, + "memoStore.unknownSymbol": unmemoizedImmutable, + "memoStore.globalThisSymbol": unmemoizedImmutable, + "memoStore.mergedSymbols": unmemoizedImmutable, + "memoStore.mergesFrozen": unmemoizedImmutable, + "memoStore.anyType": unmemoizedImmutable, + "memoStore.autoType": unmemoizedImmutable, + "memoStore.wildcardType": unmemoizedImmutable, + "memoStore.blockedStringType": unmemoizedImmutable, + "memoStore.errorType": unmemoizedImmutable, + "memoStore.unresolvedType": unmemoizedImmutable, + "memoStore.nonInferrableAnyType": unmemoizedImmutable, + "memoStore.intrinsicMarkerType": unmemoizedImmutable, + "memoStore.unknownType": unmemoizedImmutable, + "memoStore.undefinedType": unmemoizedImmutable, + "memoStore.undefinedWideningType": unmemoizedImmutable, + "memoStore.missingType": unmemoizedImmutable, + "memoStore.undefinedOrMissingType": unmemoizedImmutable, + "memoStore.optionalType": unmemoizedImmutable, + "memoStore.nullType": unmemoizedImmutable, + "memoStore.nullWideningType": unmemoizedImmutable, + "memoStore.stringType": unmemoizedImmutable, + "memoStore.numberType": unmemoizedImmutable, + "memoStore.bigintType": unmemoizedImmutable, + "memoStore.regularFalseType": unmemoizedImmutable, + "memoStore.falseType": unmemoizedImmutable, + "memoStore.regularTrueType": unmemoizedImmutable, + "memoStore.trueType": unmemoizedImmutable, + "memoStore.booleanType": unmemoizedImmutable, + "memoStore.esSymbolType": unmemoizedImmutable, + "memoStore.voidType": unmemoizedImmutable, + "memoStore.neverType": unmemoizedImmutable, + "memoStore.silentNeverType": unmemoizedImmutable, + "memoStore.implicitNeverType": unmemoizedImmutable, + "memoStore.unreachableNeverType": unmemoizedImmutable, + "memoStore.nonPrimitiveType": unmemoizedImmutable, + "memoStore.stringOrNumberType": unmemoizedImmutable, + "memoStore.stringNumberSymbolType": unmemoizedImmutable, + "memoStore.numberOrBigIntType": unmemoizedImmutable, + "memoStore.templateConstraintType": unmemoizedImmutable, + "memoStore.numericStringType": unmemoizedImmutable, + "memoStore.uniqueLiteralType": unmemoizedImmutable, + "memoStore.emptyObjectType": unmemoizedImmutable, + "memoStore.emptyJsxObjectType": unmemoizedImmutable, + "memoStore.emptyFreshJsxObjectType": unmemoizedImmutable, + "memoStore.emptyTypeLiteralType": unmemoizedImmutable, + "memoStore.unknownEmptyObjectType": unmemoizedImmutable, + "memoStore.unknownUnionType": unmemoizedImmutable, + "memoStore.emptyGenericType": unmemoizedImmutable, + "memoStore.anyFunctionType": unmemoizedImmutable, + "memoStore.noConstraintType": unmemoizedImmutable, + "memoStore.circularConstraintType": unmemoizedImmutable, + "memoStore.resolvingDefaultType": unmemoizedImmutable, + "memoStore.markerSuperType": unmemoizedImmutable, + "memoStore.markerSubType": unmemoizedImmutable, + "memoStore.markerOtherType": unmemoizedImmutable, + "memoStore.markerSuperTypeForCheck": unmemoizedImmutable, + "memoStore.markerSubTypeForCheck": unmemoizedImmutable, + "memoStore.noTypePredicate": unmemoizedImmutable, + "memoStore.anySignature": unmemoizedImmutable, + "memoStore.unknownSignature": unmemoizedImmutable, + "memoStore.resolvingSignature": unmemoizedImmutable, + "memoStore.globalIDs": unmemoizedImmutable, + "memoStore.silentNeverSignature": unmemoizedImmutable, + "memoStore.enumNumberIndexInfo": unmemoizedImmutable, + "memoStore.anyBaseTypeIndexInfo": unmemoizedImmutable, + "memoStore.patternAmbientModules": unmemoizedImmutable, + "memoStore.patternAmbientModuleAugmentations": unmemoizedImmutable, + "memoStore.patternAmbientModuleAugmentationTargets": unmemoizedImmutable, + "memoStore.globalObjectType": unmemoizedImmutable, + "memoStore.globalFunctionType": unmemoizedImmutable, + "memoStore.globalCallableFunctionType": unmemoizedImmutable, + "memoStore.globalNewableFunctionType": unmemoizedImmutable, + "memoStore.globalArrayType": unmemoizedImmutable, + "memoStore.globalReadonlyArrayType": unmemoizedImmutable, + "memoStore.globalStringType": unmemoizedImmutable, + "memoStore.globalNumberType": unmemoizedImmutable, + "memoStore.globalBooleanType": unmemoizedImmutable, + "memoStore.globalRegExpType": unmemoizedImmutable, + "memoStore.globalThisType": unmemoizedImmutable, + "memoStore.anyArrayType": unmemoizedImmutable, + "memoStore.autoArrayType": unmemoizedImmutable, + "memoStore.anyReadonlyArrayType": unmemoizedImmutable, + "memoStore.emptyStringType": unmemoizedImmutable, + "memoStore.zeroType": unmemoizedImmutable, + "memoStore.zeroBigIntType": unmemoizedImmutable, + "memoStore.typeofType": unmemoizedImmutable, + "memoStore.subtypeRelation": unmemoizedImmutable, + "memoStore.strictSubtypeRelation": unmemoizedImmutable, + "memoStore.assignableRelation": unmemoizedImmutable, + "memoStore.comparableRelation": unmemoizedImmutable, + "memoStore.identityRelation": unmemoizedImmutable, + "memoStore.nodeLinks": unmemoizedContainer, + "memoStore.signatureLinks": unmemoizedContainer, + "memoStore.symbolNodeLinks": unmemoizedContainer, + "memoStore.typeNodeLinks": unmemoizedContainer, + "memoStore.enumMemberLinks": unmemoizedContainer, + "memoStore.arrayLiteralLinks": unmemoizedContainer, + "memoStore.switchStatementLinks": unmemoizedContainer, + "memoStore.jsxElementLinks": unmemoizedContainer, + "memoStore.computedNameLinks": unmemoizedContainer, + "memoStore.symbolReferenceLinks": unmemoizedContainer, + "memoStore.valueSymbolLinks": unmemoizedContainer, + "memoStore.mappedSymbolLinks": unmemoizedContainer, + "memoStore.deferredSymbolLinks": unmemoizedContainer, + "memoStore.aliasSymbolLinks": unmemoizedContainer, + "memoStore.moduleSymbolLinks": unmemoizedContainer, + "memoStore.lateBoundLinks": unmemoizedContainer, + "memoStore.exportTypeLinks": unmemoizedContainer, + "memoStore.membersAndExportsLinks": unmemoizedContainer, + "memoStore.typeAliasLinks": unmemoizedContainer, + "memoStore.declaredTypeLinks": unmemoizedContainer, + "memoStore.spreadLinks": unmemoizedContainer, + "memoStore.varianceLinks": unmemoizedContainer, + "memoStore.ReverseMappedSymbolLinks": unmemoizedContainer, + "memoStore.markedAssignmentSymbolLinks": unmemoizedContainer, + "memoStore.sourceFileLinks": unmemoizedContainer, + "memoStore.emitResolverLinks": unmemoizedContainer, + "EmitResolverLinks.jsxLinks": unmemoizedContainer, + "EmitResolverLinks.declarationLinks": unmemoizedContainer, + "EmitResolverLinks.declarationFileLinks": unmemoizedContainer, + "memoStore.TypeCount": unmemoizedCounter, + "memoStore.memberLayoutCount": unmemoizedCounter, + "memoStore.SymbolCount": unmemoizedCounter, + "memoStore.SignatureCount": unmemoizedCounter, + "memoStore.TotalInstantiationCount": unmemoizedCounter, + "memoStore.nanType": unmemoizedInterned, + "memoStore.parentLateBindableKinds": unmemoizedSyntax, + "memoStore.packagesMap": unmemoizedProgram, + "memoStore.ambientModulesOnce": unmemoizedProgram, + "memoStore.ambientModules": unmemoizedProgram, + "memoStore.memoStates": unmemoizedMemoState, + "memoStore.memoPendingCount": unmemoizedMemoState, + "memoStore.memoErrorStates": unmemoizedMemoState, + "memoStore.stateFilter": unmemoizedMemoState, + "memoStore.errorFilter": unmemoizedMemoState, + "memoStore.mu": unmemoizedMemoState, + "memoStore.diagnostics": unmemoizedChecking, + "memoStore.suggestionDiagnostics": unmemoizedChecking, + "memoStore.nonExistentPropertyNodes": unmemoizedChecking, + "memoStore.deferredDiagnosticCallbacks": unmemoizedChecking, + "SymbolReferenceLinks.referenceKinds": unmemoizedChecking, + "AliasSymbolLinks.referenced": unmemoizedMark, + "SourceFileLinks.typeChecked": unmemoizedChecking, + "SourceFileLinks.unusedChecked": unmemoizedChecking, + "SourceFileLinks.deferredNodes": unmemoizedChecking, + "SourceFileLinks.identifierCheckNodes": unmemoizedChecking, + "SourceFileLinks.renamedBindingElements": unmemoizedSyntax, + "ValueSymbolLinks.target": unmemoizedCreated, + "ValueSymbolLinks.mapper": unmemoizedCreated, + "ValueSymbolLinks.extra": unmemoizedCreated, + "MappedSymbolLinks.keyType": unmemoizedCreated, + "MappedSymbolLinks.syntheticOrigin": unmemoizedCreated, + "DeferredSymbolLinks.parent": unmemoizedCreated, + "DeferredSymbolLinks.constituents": unmemoizedCreated, + "DeferredSymbolLinks.writeConstituents": unmemoizedCreated, + "ReverseMappedSymbolLinks.propertyType": unmemoizedCreated, + "ReverseMappedSymbolLinks.mappedType": unmemoizedCreated, + "ReverseMappedSymbolLinks.constraintType": unmemoizedCreated, + "ExportTypeLinks.target": unmemoizedCreated, + "ExportTypeLinks.originatingImport": unmemoizedCreated, + "SpreadLinks.leftSpread": unmemoizedCreated, + "SpreadLinks.rightSpread": unmemoizedCreated, + "JsxElementLinks.firstJSXTagInFile": unmemoizedSyntax, + "memoStore._jsxNamespace": unmemoizedSyntax, + "memoStore._jsxFactoryEntity": unmemoizedSyntax, + "SwitchStatementLinks.witnessesComputed": unmemoizedSyntax, + "SwitchStatementLinks.witnesses": unmemoizedSyntax, + "ArrayLiteralLinks.indicesComputed": unmemoizedSyntax, + "ArrayLiteralLinks.firstSpreadIndex": unmemoizedSyntax, + "ArrayLiteralLinks.lastSpreadIndex": unmemoizedSyntax, + "NodeLinks.declarationRequiresScopeChange": unmemoizedSyntax, + "SourceFileLinks.localJsxNamespace": unmemoizedSyntax, + "SourceFileLinks.localJsxFragmentNamespace": unmemoizedSyntax, + "SourceFileLinks.localJsxFactory": unmemoizedSyntax, + "SourceFileLinks.localJsxFragmentFactory": unmemoizedSyntax, + "JsxElementLinks.jsxFlags": unmemoizedFlagMemo, + "JsxElementLinks.jsxImplicitImportContainer": unmemoizedFlagMemo, + "flowLoopCacheEntry.t": unmemoizedLoopFixpoint, + "flowLoopCacheEntry.tooDeep": unmemoizedLoopFixpoint, + "instantiationExpressionEntry.t": unmemoizedFlagMemo, + "ModuleSymbolLinks.resolvedExports": unmemoizedFlagMemo, + "ModuleSymbolLinks.typeOnlyExportStarMap": unmemoizedFlagMemo, + "LateBoundLinks.lateSymbol": unmemoizedGuarded, + "TypeAliasLinks.typeParameters": unmemoizedGuarded, + "MarkedAssignmentSymbolLinks.lastAssignmentPos": unmemoizedGuarded, + "MarkedAssignmentSymbolLinks.hasDefiniteAssignment": unmemoizedGuarded, + "EnumMemberLinks.value": unmemoizedGuarded, + "JSXLinks.importRef": unmemoizedEmit, + "DeclarationLinks.madeVisible": unmemoizedEmit, + "DeclarationLinks.ruleKnown": unmemoizedSyntax, + "DeclarationLinks.ruleVisible": unmemoizedSyntax, + "DeclarationLinks.ruleInheritsFrom": unmemoizedSyntax, + "DeclarationFileLinks.aliasesMarked": unmemoizedEmit, + "NodeBuilderLinks.serializedTypes": unmemoizedNodeBuilder, + "NodeBuilderLinks.fakeScopeForSignatureDeclaration": unmemoizedNodeBuilder, + "NodeBuilderSymbolLinks.specifierCache": unmemoizedNodeBuilder, + "SourceFileLinks.externalHelpersModule": unmemoizedChecking, + "SourceFileLinks.requestedExternalEmitHelpers": unmemoizedChecking, + "SourceFileLinks.externalHelperRequests": unmemoizedChecking, + "AliasSymbolLinks.typeOnlyDeclaration": unmemoizedGuarded, + "NodeLinks.flags": unmemoizedNodeFlags, +} diff --git a/tsc/internal/checker/checkerstate.go b/tsc/internal/checker/checkerstate.go new file mode 100644 index 0000000000000..bf0150558747c --- /dev/null +++ b/tsc/internal/checker/checkerstate.go @@ -0,0 +1,106 @@ +package checker + +import ( + "fmt" + "reflect" +) + +// checkerProgressFields are the fields of Checker holding the state of the +// computations in progress. Between requests it is at rest, as the next +// request would read anything one request left there. See +// TestCachedStateIsMemoized for the other fields of Checker. +var checkerProgressFields = []string{ + "activeMappers", + "activeTypeMappersCaches", + "antecedentTypes", + "baseConstraintWalk", + "checking", + "circularityMark", + "circularityStart", + "conditionalConstraintDepth", + "contextualInfos", + "contextualParameterAssignments", + "ctx", + "currentNode", + "currentNodeErrorCollectors", + "currentNodeErrors", + "currentNodeErrorsCyclic", + "currentNodeResolution", + "cycleParticipants", + "cycleYields", + "deferredAttach", + "discardLog", + "discardLogFloor", + "effectsMarkDepth", + "flowLoopStack", + "flowTypeCache", + "heldEffects", + "heldEffectsFloor", + "inferenceContextInfos", + "inlineLevel", + "innerCycles", + "instantiationAbortLog", + "instantiationAbortRoot", + "instantiationAborted", + "instantiationStack", + "markingForEmit", + "memoTop", + "observedHead", + "observingMemos", + "parametersAssigning", + "queryRoot", + "querySave", + "readIncompleteFloor", + "recordingFromCheck", + "reliabilityFlags", + "request", + "resolutionStart", + "resolutions", + "resolving", + "resolvingObjectTypeStack", + "reverseExpandingFlags", + "reverseMappedSourceStack", + "reverseMappedStart", + "reverseMappedTargetStack", + "serializationLevel", + "sharedFlows", + "signaturesResolving", + "typeResolutionTop", + "varianceCycleRoot", + "varianceProvisional", + "varianceStack", + "varianceSuperseded", + "varianceTypeParameter", + "visibleSignatures", + "visibleStart", + "withinUnreachableCode", +} + +// AssertAtRest panics if the state of the computations in progress is not at +// rest, as it must be between requests. +func (c *Checker) AssertAtRest() { + v := reflect.ValueOf(c).Elem() + for _, name := range checkerProgressFields { + f := v.FieldByName(name) + var rest bool + switch name { + case "resolutions": + // The root resolution, for work outside any computation. + rest = f.Len() == 1 + case "resolving": + rest = c.resolving.count == 0 + case "observingMemos": + rest = f.Bool() == (!c.checking || c.memoPendingCount != 0) + default: + switch f.Kind() { + case reflect.Slice, reflect.Map: + rest = f.Len() == 0 + default: + rest = f.IsZero() + } + } + if !rest { + panic(fmt.Sprintf("checker state %s is not at rest between requests", name)) + } + } +} diff --git a/tsc/internal/checker/emitresolver.go b/tsc/internal/checker/emitresolver.go index e4fad5c3f5b1f..0f96089a8fefe 100644 --- a/tsc/internal/checker/emitresolver.go +++ b/tsc/internal/checker/emitresolver.go @@ -22,8 +22,16 @@ type JSXLinks struct { // Links for declarations +// DeclarationLinks hold whether a declaration is visible. Declaration emit +// makes the declarations it depends on visible as it goes, so that is kept +// apart from what the rules of the declaration say, which is all that is +// cached: a declaration found invisible before emit made it or its container +// visible is still found visible afterwards. type DeclarationLinks struct { - isVisible core.Tristate // if declaration is depended upon by exported declarations + madeVisible bool // Declaration emit depends on the declaration + ruleKnown bool // Whether ruleVisible and ruleInheritsFrom are known + ruleVisible bool // Whether the declaration is visible by its own rules + ruleInheritsFrom *ast.Node // A declaration it is as visible as, if any } type DeclarationFileLinks struct { @@ -186,7 +194,7 @@ func (r *EmitResolver) markLinkedAliases(node *ast.Node) { var nextSymbol *ast.Symbol for _, declaration := range exportSymbol.Declarations() { - r.checker.emitResolverLinks.declarationLinks.Get(declaration).isVisible = core.TSTrue + r.checker.emitResolverLinks.declarationLinks.Get(declaration).madeVisible = true if ast.IsInternalModuleImportEqualsDeclaration(declaration) { // Add the referenced top container visible @@ -398,11 +406,12 @@ func (r *EmitResolver) IsReferencedAliasDeclaration(node *ast.Node) bool { if aliasLinks.referenced { return true } - target := aliasLinks.aliasTarget - if target != nil && node.ModifierFlags()&ast.ModifierFlagsExport != 0 && - c.getSymbolFlags(target)&ast.SymbolFlagsValue != 0 && - (c.compilerOptions.ShouldPreserveConstEnums() || !isConstEnumOrConstEnumOnlyModule(target)) { - return true + if node.ModifierFlags()&ast.ModifierFlagsExport != 0 { + target := c.resolveAlias(symbol) + if target != c.unknownSymbol && c.getSymbolFlags(target)&ast.SymbolFlagsValue != 0 && + (c.compilerOptions.ShouldPreserveConstEnums() || !isConstEnumOrConstEnumOnlyModule(target)) { + return true + } } } } @@ -502,6 +511,8 @@ func (r *EmitResolver) MarkLinkedReferencesRecursively(file *ast.SourceFile) { defer r.checkerMu.Unlock() if file != nil { + r.checker.markingForEmit = true + defer func() { r.checker.markingForEmit = false }() var visit ast.Visitor visit = func(n *ast.Node) bool { if ast.IsImportEqualsDeclaration(n) && n.ModifierFlags()&ast.ModifierFlagsExport == 0 { @@ -532,7 +543,7 @@ func (r *EmitResolver) getReferenceResolver() binder.ReferenceResolver { if r.referenceResolver == nil { r.referenceResolver = binder.NewReferenceResolver(r.checker.compilerOptions, binder.ReferenceResolverHooks{ ResolveName: r.checker.resolveName, - GetResolvedSymbol: r.checker.getResolvedSymbolOrNil, + GetResolvedSymbol: r.checker.getSymbolOfReferenceForEmit, GetMergedSymbol: r.checker.getMergedSymbol, GetParentOfSymbol: r.checker.getParentOfSymbol, GetSymbolOfDeclaration: r.checker.getSymbolOfDeclaration, diff --git a/tsc/internal/checker/emitsupport.go b/tsc/internal/checker/emitsupport.go index 3da782c9ab4c4..4044c67089955 100644 --- a/tsc/internal/checker/emitsupport.go +++ b/tsc/internal/checker/emitsupport.go @@ -5,7 +5,6 @@ import ( "slices" "github.com/microsoft/TypeScript/tsc/internal/ast" - "github.com/microsoft/TypeScript/tsc/internal/core" "github.com/microsoft/TypeScript/tsc/internal/printer" ) @@ -17,27 +16,40 @@ func (c *Checker) isDeclarationVisible(node *ast.Node) bool { return false } - links := c.emitResolverLinks.declarationLinks.Get(node) - if links.isVisible == core.TSUnknown { - if c.determineIfDeclarationIsVisible(node) { - links.isVisible = core.TSTrue - } else { - links.isVisible = core.TSFalse + for { + links := c.emitResolverLinks.declarationLinks.Get(node) + if links.madeVisible { + return true + } + if !links.ruleKnown { + links.ruleVisible, links.ruleInheritsFrom = c.determineIfDeclarationIsVisible(node) + links.ruleKnown = true + } + if links.ruleInheritsFrom == nil { + return links.ruleVisible + } + node = links.ruleInheritsFrom + if !ast.IsParseTreeNode(node) { + return false } } - return links.isVisible == core.TSTrue } -func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { +// determineIfDeclarationIsVisible returns whether node is visible by the rules +// of its declaration alone, or, if those make it as visible as another +// declaration, that declaration. Which declarations are visible depends on +// what declaration emit makes visible (see DeclarationLinks), so whether +// another declaration is visible is not part of the result. +func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) (visible bool, inheritsFrom *ast.Node) { switch node.Kind { case ast.KindJSDocCallbackTag, // ast.KindJSDocEnumTag, // !!! TODO: JSDoc @enum support? ast.KindJSDocTypedefTag: // Top-level jsdoc type aliases are considered exported // First parent is comment node, second is hosting declaration or token; we only care about those tokens or declarations whose parent is a source file - return node.Parent != nil && node.Parent.Parent != nil && node.Parent.Parent.Parent != nil && ast.IsSourceFile(node.Parent.Parent.Parent) + return node.Parent != nil && node.Parent.Parent != nil && node.Parent.Parent.Parent != nil && ast.IsSourceFile(node.Parent.Parent.Parent), nil case ast.KindBindingElement: - return c.isDeclarationVisible(node.Parent.Parent) + return false, node.Parent.Parent case ast.KindVariableDeclaration, ast.KindModuleDeclaration, ast.KindClassDeclaration, @@ -51,23 +63,23 @@ func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { if ast.IsBindingPattern(node.Name()) && len(node.Name().Elements()) == 0 { // If the binding pattern is empty, this variable declaration is not visible - return false + return false, nil } // falls through } // External module augmentation is always visible // A @typedef at top-level in an external module is always visible if ast.IsExternalModuleAugmentation(node) || ast.IsImplicitlyExportedJSDocDeclaration(node) { - return true + return true, nil } parent := ast.GetDeclarationContainer(node) // If the node is not exported or it is not ambient module element (except import declaration) if c.getCombinedModifierFlagsCached(node)&ast.ModifierFlagsExport == 0 && !(node.Kind != ast.KindImportEqualsDeclaration && parent.Kind != ast.KindSourceFile && parent.Flags&ast.NodeFlagsAmbient != 0) { - return ast.IsGlobalSourceFile(parent) + return ast.IsGlobalSourceFile(parent), nil } // Exported members/ambient module elements (exception import declaration) are visible if parent is visible - return c.isDeclarationVisible(parent) + return false, parent case ast.KindPropertyDeclaration, ast.KindPropertySignature, @@ -77,10 +89,10 @@ func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { ast.KindMethodSignature: if c.GetEffectiveDeclarationFlags(node, ast.ModifierFlagsPrivate|ast.ModifierFlagsProtected) != 0 { // Private/protected properties/methods are not visible - return false + return false, nil } // Public properties/methods are visible if its parents are visible, so: - return c.isDeclarationVisible(node.Parent) + return false, node.Parent case ast.KindConstructor, ast.KindConstructSignature, @@ -98,38 +110,38 @@ func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { ast.KindIntersectionType, ast.KindParenthesizedType, ast.KindNamedTupleMember: - return c.isDeclarationVisible(node.Parent) + return false, node.Parent // Default binding, import specifier and namespace import is visible // only on demand so by default it is not visible case ast.KindImportClause, ast.KindNamespaceImport, ast.KindImportSpecifier: - return false + return false, nil // Type parameters are always visible case ast.KindTypeParameter: - return true + return true, nil // Source file and namespace export are always visible case ast.KindSourceFile, ast.KindNamespaceExportDeclaration: - return true + return true, nil // Export assignments do not create name bindings outside the module case ast.KindExportAssignment: - return false + return false, nil // An `export {X}` (without a module specifier) is itself a visible re-export of // the named binding; it contributes to the symbol's external visibility. case ast.KindExportSpecifier: exportDecl := node.Parent.Parent if ast.IsExportDeclaration(exportDecl) && exportDecl.AsExportDeclaration().ModuleSpecifier == nil { - return c.isDeclarationVisible(exportDecl.Parent) + return false, exportDecl.Parent } - return false + return false, nil default: - return false + return false, nil } } @@ -205,7 +217,7 @@ func (c *Checker) hasVisibleDeclarations(symbol *ast.Symbol, shouldComputeAliasT var addVisibleAlias func(declaration *ast.Node, aliasingStatement *ast.Node) if shouldComputeAliasToMakeVisible { addVisibleAlias = func(declaration *ast.Node, aliasingStatement *ast.Node) { - c.emitResolverLinks.declarationLinks.Get(declaration).isVisible = core.TSTrue + c.emitResolverLinks.declarationLinks.Get(declaration).madeVisible = true if aliasesToMakeVisibleSet == nil { aliasesToMakeVisibleSet = make(map[ast.NodeId]*ast.Node) } diff --git a/tsc/internal/checker/exports.go b/tsc/internal/checker/exports.go index 26c6e8180454d..c23017e907c3f 100644 --- a/tsc/internal/checker/exports.go +++ b/tsc/internal/checker/exports.go @@ -469,3 +469,19 @@ func (c *Checker) CompareSymbols(s1, s2 *ast.Symbol) int { func IsDistributedTypeParameter(t *Type) bool { return t.flags&TypeFlagsTypeParameter != 0 && t.AsTypeParameter().isDistributed } + +func (c *Checker) GetTypeParameterOfMappedType(t *Type) *Type { + return c.getTypeParameterFromMappedType(t) +} + +func (c *Checker) GetConstraintTypeOfMappedType(t *Type) *Type { + return c.getConstraintTypeFromMappedType(t) +} + +func (c *Checker) GetNameTypeOfMappedType(t *Type) *Type { + return c.getNameTypeFromMappedType(t) +} + +func (c *Checker) GetTemplateTypeOfMappedType(t *Type) *Type { + return c.getTemplateTypeFromMappedType(t) +} diff --git a/tsc/internal/checker/flow.go b/tsc/internal/checker/flow.go index 8d14ca5258079..cea7b709d9754 100644 --- a/tsc/internal/checker/flow.go +++ b/tsc/internal/checker/flow.go @@ -44,6 +44,8 @@ type FlowState struct { flowContainer *ast.Node refKey CacheHashKey depth int + depthBase int // depth of the loop analyses depth is measured from + limitHits int sharedFlowStart int reduceLabels []*ast.FlowReduceLabelData next *FlowState @@ -79,9 +81,6 @@ func (c *Checker) getFlowTypeOfReference(reference *ast.Node, declaredType *Type } func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Type, initialType *Type, flowContainer *ast.Node, flowNode *ast.FlowNode) *Type { - if c.flowAnalysisDisabled { - return c.errorType - } if flowNode == nil { flowNode = getFlowNodeOfNode(reference) if flowNode == nil { @@ -96,6 +95,11 @@ func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Ty f.sharedFlowStart = len(c.sharedFlows) c.flowInvocationCount++ evolvedType := c.getTypeAtFlowNode(f, flowNode).t + if f.limitHits != 0 { + // Give up on the whole reference, so its type does not depend on how + // deep the walk got before giving up. + evolvedType = c.errorType + } c.sharedFlows = c.sharedFlows[:f.sharedFlowStart] c.putFlowState(f) // When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation, @@ -114,14 +118,94 @@ func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Ty return resultType } +// A walk gives up after maxFlowDepth nested steps. Each loop is analyzed +// once per reference key and its result is cached, so the analysis of a +// loop measures depth from the loop rather than from the reference that +// reached it first. maxFlowTotalDepth only guards the call stack against +// loop analyses nested so deeply that the walk is certain to be runaway. +const ( + maxFlowDepth = 2000 + maxFlowTotalDepth = 20 * maxFlowDepth +) + func (c *Checker) getTypeAtFlowNode(f *FlowState, flow *ast.FlowNode) FlowType { - if f.depth == 2000 { + // A walk that is too deep from a node is also too deep from it with less + // depth left, so remember the failure to avoid repeating it for every + // reference after the first. Loops being analyzed and reduce labels make + // walks depend on more than the node and reference, so such walks are not + // remembered. + if len(c.flowDepthFailures) != 0 && c.isRememberedFlowDepthFailure(f, flow) { + return FlowType{t: c.errorType} + } + hits := f.limitHits + t := c.getTypeAtFlowNodeWorker(f, flow) + if f.limitHits != hits { + c.rememberFlowDepthFailure(f, flow) + } + return t +} + +// isRememberedFlowDepthFailure reports whether a walk from flow is known to +// be too deep for the depth left, reporting the failure if so. +// +//go:noinline +func (c *Checker) isRememberedFlowDepthFailure(f *FlowState, flow *ast.FlowNode) bool { + if len(c.flowLoopStack) != 0 || len(f.reduceLabels) != 0 || !c.hasFlowReferenceKey(f) { + return false + } + if b, ok := c.flowDepthFailures[FlowLoopKey{flowNode: flow, refKey: f.refKey}]; ok && maxFlowDepth-f.depth <= b { + f.limitHits++ + c.reportFlowControlError(f.reference) + return true + } + return false +} + +// rememberFlowDepthFailure remembers that a walk from flow was too deep for +// the depth left. +// +//go:noinline +func (c *Checker) rememberFlowDepthFailure(f *FlowState, flow *ast.FlowNode) { + if len(c.flowLoopStack) != 0 || len(f.reduceLabels) != 0 || !c.hasFlowReferenceKey(f) { + return + } + budget := maxFlowDepth - f.depth + key := FlowLoopKey{flowNode: flow, refKey: f.refKey} + if b, ok := c.flowDepthFailures[key]; !ok || b < budget { + if c.flowDepthFailures == nil { + c.flowDepthFailures = make(map[FlowLoopKey]int) + } + if c.logResults() { + // The walk may have depended on results a cycle in progress + // discards. + c.logRestore(func() { + if ok { + c.flowDepthFailures[key] = b + } else { + delete(c.flowDepthFailures, key) + } + }) + } + c.flowDepthFailures[key] = budget + } +} + +func (c *Checker) hasFlowReferenceKey(f *FlowState) bool { + if f.refKey.IsZero() { + f.refKey = c.getFlowReferenceKey(f) + } + return f.refKey != nonDottedNameCacheKey +} + +func (c *Checker) getTypeAtFlowNodeWorker(f *FlowState, flow *ast.FlowNode) FlowType { + if f.depth == maxFlowDepth || f.depthBase+f.depth == maxFlowTotalDepth { // We have made 2000 recursive invocations. To avoid overflowing the call stack we report an error - // and disable further control flow analysis in the containing function or module body. + // and give up on this reference. Each reference hits the limit on its own, so its type does not depend + // on which other references were analyzed first; see getTypeAtFlowNode. if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "getTypeAtFlowNode_DepthLimit", map[string]any{"depth": f.depth}) } - c.flowAnalysisDisabled = true + f.limitHits++ c.reportFlowControlError(f.reference) return FlowType{t: c.errorType} } @@ -134,9 +218,9 @@ func (c *Checker) getTypeAtFlowNode(f *FlowState, flow *ast.FlowNode) FlowType { // the same getFlowTypeOfReference invocation. A node is considered shared when it is the // antecedent of more than one node. for i := f.sharedFlowStart; i < len(c.sharedFlows); i++ { - if c.sharedFlows[i].flow == flow { + if s := &c.sharedFlows[i]; s.flow == flow { f.depth-- - return c.sharedFlows[i].flowType + return s.flowType } } sharedFlow = flow @@ -383,14 +467,14 @@ func (c *Checker) narrowType(f *FlowState, t *Type, expr *ast.Node, assumeTrue b case ast.KindIdentifier: // When narrowing a reference to a const variable, non-assigned parameter, or readonly property, we inline // up to five levels of aliased conditional expressions that are themselves declared as const variables. - if !c.isMatchingReference(f.reference, expr) && c.inlineLevel < 5 { + if !c.isMatchingReference(f.reference, expr) { symbol := c.getResolvedSymbol(expr) if c.isConstantVariable(symbol) { declaration := symbol.ValueDeclaration() - if declaration != nil && ast.IsVariableDeclaration(declaration) && declaration.Type() == nil && declaration.Initializer() != nil && c.isConstantReference(f.reference) { - c.inlineLevel++ + if declaration != nil && ast.IsVariableDeclaration(declaration) && declaration.Type() == nil && declaration.Initializer() != nil && c.isConstantReference(f.reference) && !c.depthLimitReached(&c.inlineLevel, 5) { + c.enterDepthLimit(&c.inlineLevel) result := c.narrowType(f, t, declaration.Initializer(), assumeTrue) - c.inlineLevel-- + c.exitDepthLimit(&c.inlineLevel) return result } } @@ -848,11 +932,13 @@ func (c *Checker) getNarrowedType(t *Type, candidate *Type, assumeTrue bool, che return c.getNarrowedTypeWorker(t, candidate, assumeTrue, checkDerived) } key := NarrowedTypeKey{t, candidate, assumeTrue, checkDerived} - if narrowedType, ok := c.narrowedTypes[key]; ok { + if narrowedType, ok := c.narrowedTypes.cached(c, key); ok { return narrowedType } + c.narrowedTypes.begin(c, key) narrowedType := c.getNarrowedTypeWorker(t, candidate, assumeTrue, checkDerived) - c.narrowedTypes[key] = narrowedType + c.narrowedTypes.set(c, key, narrowedType) + c.endMemo() return narrowedType } @@ -1331,11 +1417,46 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT return FlowType{t: f.declaredType} } key := FlowLoopKey{flowNode: flow, refKey: f.refKey} + entry, _ := c.flowLoopCache.get(key) + if entry == nil { + entry = &flowLoopCacheEntry{} + c.flowLoopCache.intern(key, entry) + } // If we have previously computed the control flow type for the reference at // this flow loop junction, return the cached type. - if cached := c.flowLoopCache[key]; cached != nil { - return FlowType{t: cached} + if entry.t != nil { + c.observeFlagMemo(memoKeyOf(entry, memoFlowLoopType)) + if entry.tooDeep { + // Analyzing the loop again would give up again. + f.limitHits++ + c.reportFlowControlError(f.reference) + } + return FlowType{t: entry.t} + } + c.beginMemo(memoKeyOf(entry, memoFlowLoopType)) + // The result is cached for every reference with this key, so the analysis + // neither uses the depth left to this reference nor the nodes this + // reference already visited, and the nodes it visits are not reused + // after it. + depth, depthBase, sharedFlowStart, hits := f.depth, f.depthBase, f.sharedFlowStart, f.limitHits + f.depthBase += f.depth + f.depth = 0 + f.sharedFlowStart = len(c.sharedFlows) + result := c.getTypeAtFlowLoopLabelUncached(f, flow, key, entry) + c.sharedFlows = c.sharedFlows[:f.sharedFlowStart] + f.depth, f.depthBase, f.sharedFlowStart = depth, depthBase, sharedFlowStart + if f.limitHits != hits { + entry.tooDeep = entry.t != nil + } else if entry.tooDeep { + // Another reference completed the analysis meanwhile. + f.limitHits++ + c.reportFlowControlError(f.reference) } + c.endMemo() + return result +} + +func (c *Checker) getTypeAtFlowLoopLabelUncached(f *FlowState, flow *ast.FlowNode, key FlowLoopKey, entry *flowLoopCacheEntry) FlowType { // If this flow loop junction and reference are already being processed, return // the union of the types computed for each branch so far, marked as incomplete. // It is possible to see an empty array in cases where loops are nested and the @@ -1364,17 +1485,24 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT } else { // All but the first antecedent are the looping control flow paths that lead // back to the loop junction. We track these on the flow loop stack. + sharedFlowStart := len(c.sharedFlows) c.flowLoopStack = append(c.flowLoopStack, FlowLoopInfo{key: key, types: antecedentTypes}) saveFlowTypeCache := c.flowTypeCache c.flowTypeCache = nil flowType = c.getTypeAtFlowNode(f, list.Flow) c.flowTypeCache = saveFlowTypeCache c.flowLoopStack = c.flowLoopStack[:len(c.flowLoopStack)-1] + // An incomplete type computed under the back edge reflects the loop's + // partial types, so it is not valid once the back edge is exited. + // Reusing it would make the result depend on which reference was + // analyzed first. + kept := slices.DeleteFunc(c.sharedFlows[sharedFlowStart:], func(s SharedFlow) bool { return s.flowType.incomplete }) + c.sharedFlows = c.sharedFlows[:sharedFlowStart+len(kept)] // If we see a value appear in the cache it is a sign that control flow analysis // was restarted and completed by checkExpressionCached. We can simply pick up // the resulting type and bail out. - if cached := c.flowLoopCache[key]; cached != nil { - return FlowType{t: cached} + if entry.t != nil { + return FlowType{t: entry.t} } } antecedentTypes = core.AppendIfUnique(antecedentTypes, flowType.t) @@ -1397,7 +1525,10 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT if firstAntecedentType.incomplete { return c.newFlowType(result, true /*incomplete*/) } - c.flowLoopCache[key] = result + // Kept even if a cycle in progress discards what it computed: analyzing + // the loop again after the cycle starts from wherever the next reference + // is, and may then reach a different fixed point. + entry.t = result return FlowType{t: result} } @@ -1508,11 +1639,11 @@ func getCandidateVariableDeclarationInitializer(node *ast.Node) *ast.Node { // and never escape the getFlowTypeOfReference function. func (c *Checker) getEvolvingArrayType(elementType *Type) *Type { key := CachedTypeKey{kind: CachedTypeKindEvolvingArrayType, typeId: elementType.id} - result := c.cachedTypes[key] + result, _ := c.cachedTypes.cached(c, key) if result == nil { result = c.newObjectType(ObjectFlagsEvolvingArray, nil) result.AsEvolvingArrayType().elementType = elementType - c.cachedTypes[key] = result + c.cachedTypes.intern(key, result) } return result } @@ -1571,10 +1702,7 @@ func (c *Checker) finalizeEvolvingArrayType(t *Type) *Type { } func (c *Checker) getFinalArrayType(t *EvolvingArrayType) *Type { - if t.finalArrayType == nil { - t.finalArrayType = c.createFinalArrayType(t.elementType) - } - return t.finalArrayType + return c.memoCompute(&t.finalArrayType, func() *Type { return c.createFinalArrayType(t.elementType) }) } func (c *Checker) createFinalArrayType(elementType *Type) *Type { @@ -1835,7 +1963,7 @@ func (c *Checker) isConstantReference(node *ast.Node) bool { case ast.KindPropertyAccessExpression, ast.KindElementAccessExpression: // The resolvedSymbol property is initialized by checkPropertyAccess or checkElementAccess before we get here. if c.isConstantReference(node.Expression()) { - symbol := c.getResolvedSymbolOrNil(node) + symbol := c.symbolOfCheckedExpression(node) if symbol != nil { return c.isReadonlySymbol(symbol) } @@ -1944,18 +2072,21 @@ func isCoercibleUnderDoubleEquals(source *Type, target *Type) bool { func (c *Checker) isExhaustiveSwitchStatement(node *ast.Node) bool { links := c.switchStatementLinks.Get(node) - if links.exhaustiveState == ExhaustiveStateUnknown { + switch links.exhaustiveState.cached(c) { + case ExhaustiveStateUnknown: + links.exhaustiveState.begin(c) // Indicate resolution is in process - links.exhaustiveState = ExhaustiveStateComputing + links.exhaustiveState.set(c, ExhaustiveStateComputing) isExhaustive := c.computeExhaustiveSwitchStatement(node) - if links.exhaustiveState == ExhaustiveStateComputing { - links.exhaustiveState = core.IfElse(isExhaustive, ExhaustiveStateTrue, ExhaustiveStateFalse) + if links.exhaustiveState.cached(c) == ExhaustiveStateComputing { + links.exhaustiveState.set(c, core.IfElse(isExhaustive, ExhaustiveStateTrue, ExhaustiveStateFalse)) } - } else if links.exhaustiveState == ExhaustiveStateComputing { + c.endMemo() + case ExhaustiveStateComputing: // Resolve circularity to false - links.exhaustiveState = ExhaustiveStateFalse + links.exhaustiveState.set(c, ExhaustiveStateFalse) } - return links.exhaustiveState == ExhaustiveStateTrue + return links.exhaustiveState.cached(c) == ExhaustiveStateTrue } func (c *Checker) computeExhaustiveSwitchStatement(node *ast.Node) bool { @@ -2037,16 +2168,17 @@ func (c *Checker) getNotEqualFactsFromTypeofSwitch(start int, end int, witnesses func (c *Checker) getSwitchClauseTypes(node *ast.Node) []*Type { links := c.switchStatementLinks.Get(node) - if !links.switchTypesComputed { + if links.switchTypes.cached(c) == nil { + links.switchTypes.begin(c) clauses := node.AsSwitchStatement().CaseBlock.AsCaseBlock().Clauses.Nodes types := make([]*Type, len(clauses)) for i, clause := range clauses { types[i] = c.getTypeOfSwitchClause(clause) } - links.switchTypes = types - links.switchTypesComputed = true + links.switchTypes.set(c, types) + c.endMemo() } - return links.switchTypes + return links.switchTypes.cached(c) } func (c *Checker) getTypeOfSwitchClause(clause *ast.Node) *Type { @@ -2058,8 +2190,9 @@ func (c *Checker) getTypeOfSwitchClause(clause *ast.Node) *Type { func (c *Checker) getEffectsSignature(node *ast.Node) *Signature { links := c.signatureLinks.Get(node) - signature := links.effectsSignature + signature := links.effectsSignature.cached(c) if signature == nil { + links.effectsSignature.begin(c) // A call expression parented by an expression statement is a potential assertion. Other call // expressions are potential type predicate function calls. In order to avoid triggering // circularities in control flow analysis, we use getTypeOfDottedName when resolving the call @@ -2091,7 +2224,8 @@ func (c *Checker) getEffectsSignature(node *ast.Node) *Signature { if !(signature != nil && c.hasTypePredicateOrNeverReturnType(signature)) { signature = c.unknownSignature } - links.effectsSignature = signature + links.effectsSignature.set(c, signature) + c.endMemo() } if signature == c.unknownSignature { return nil @@ -2166,10 +2300,11 @@ func (c *Checker) getTypeOfDottedName(node *ast.Node, diagnostic *ast.Diagnostic func (c *Checker) getExplicitTypeOfSymbol(symbol *ast.Symbol, diagnostic *ast.Diagnostic) *Type { symbol = c.resolveSymbol(symbol) - if !c.resolvingExplicitTypeOfSymbol.AddIfAbsent(symbol) { + if c.isResolvingAnywhere(symbol, TypeSystemPropertyNameExplicitType) { return nil } - defer c.resolvingExplicitTypeOfSymbol.Delete(symbol) + c.beginTypeResolution(symbol, TypeSystemPropertyNameExplicitType, nil) + defer c.popTypeResolution() if symbol.Flags()&(ast.SymbolFlagsFunction|ast.SymbolFlagsMethod|ast.SymbolFlagsClass|ast.SymbolFlagsValueModule) != 0 { return c.getTypeOfSymbol(symbol) } @@ -2269,16 +2404,13 @@ func (c *Checker) getInitialTypeOfVariableDeclaration(node *ast.Node) *Type { return c.errorType } +// getTypeOfInitializer returns the type of an initializer for flow analysis. +// It is the type of the expression where it is, cached apart from the type +// checking caches for it, which flow analysis would otherwise compute first: +// the cycles through the initializer would then be entered there rather than +// from the declaration. Within the analysis of a loop, it reflects the types of +// the references in progress in the loop. func (c *Checker) getTypeOfInitializer(node *ast.Node) *Type { - // Return the cached type if one is available. If the type of the variable was inferred - // from its initializer, we'll already have cached the type. Otherwise we compute it now - // without caching such that transient types are reflected. - if c.typeNodeLinks.Has(node) { - t := c.typeNodeLinks.Get(node).resolvedType - if t != nil { - return t - } - } return c.getTypeOfExpression(node) } @@ -2416,10 +2548,12 @@ func (c *Checker) getAssignmentReducedType(declaredType *Type, assignedType *Typ return assignedType } key := AssignmentReducedKey{id1: declaredType.id, id2: assignedType.id} - result := c.assignmentReducedTypes[key] + result, _ := c.assignmentReducedTypes.cached(c, key) if result == nil { + c.assignmentReducedTypes.begin(c, key) result = c.getAssignmentReducedTypeWorker(declaredType, assignedType) - c.assignmentReducedTypes[key] = result + c.assignmentReducedTypes.set(c, key, result) + c.endMemo() } return result } @@ -2526,24 +2660,30 @@ func (c *Checker) isReachableFlowNode(flow *ast.FlowNode) bool { f := c.getFlowState() result := c.isReachableFlowNodeWorker(f, flow, false /*noCacheCheck*/) c.putFlowState(f) - c.lastFlowNode = flow - c.lastFlowNodeReachable = result + // The last result is reused without accounting for reading it, so it is + // only kept where nothing computed since could be discarded. + if !c.logResults() { + c.lastFlowNode = flow + c.lastFlowNodeReachable = result + } return result } func (c *Checker) isReachableFlowNodeWorker(f *FlowState, flow *ast.FlowNode, noCacheCheck bool) bool { for { - if flow == c.lastFlowNode { + if flow == c.lastFlowNode && !c.observing() { return c.lastFlowNodeReachable } flags := flow.Flags if flags&ast.FlowFlagsShared != 0 { if !noCacheCheck && len(f.reduceLabels) == 0 { - if reachable, ok := c.flowNodeReachable[flow]; ok { + if reachable, ok := c.flowNodeReachable.cached(c, flow); ok { return reachable } + c.flowNodeReachable.begin(c, flow) reachable := c.isReachableFlowNodeWorker(f, flow, true /*noCacheCheck*/) - c.flowNodeReachable[flow] = reachable + c.flowNodeReachable.set(c, flow, reachable) + c.endMemo() return reachable } noCacheCheck = false @@ -2625,11 +2765,13 @@ func (c *Checker) isPostSuperFlowNodeWorker(f *FlowState, flow *ast.FlowNode, no flags := flow.Flags if flags&ast.FlowFlagsShared != 0 { if !noCacheCheck { - if postSuper, ok := c.flowNodePostSuper[flow]; ok { + if postSuper, ok := c.flowNodePostSuper.cached(c, flow); ok { return postSuper } + c.flowNodePostSuper.begin(c, flow) postSuper := c.isPostSuperFlowNodeWorker(f, flow, true /*noCacheCheck*/) - c.flowNodePostSuper[flow] = postSuper + c.flowNodePostSuper.set(c, flow, postSuper) + c.endMemo() return postSuper } noCacheCheck = false @@ -2684,24 +2826,16 @@ func (c *Checker) isPastLastAssignment(symbol *ast.Symbol, location *ast.Node) b return lastAssignmentPos == 0 || location != nil && int(lastAssignmentPos) < location.Pos() } +// ensureAssignmentsMarked marks the assignments within the function or file +// declaring symbol. func (c *Checker) ensureAssignmentsMarked(symbol *ast.Symbol) { parent := ast.FindAncestor(symbol.ValueDeclaration(), ast.IsFunctionOrSourceFile) if parent == nil { return } - links := c.nodeLinks.Get(parent) - if links.flags&NodeCheckFlagsAssignmentsMarked == 0 { - links.flags |= NodeCheckFlagsAssignmentsMarked - if !c.hasParentWithAssignmentsMarked(parent) { - c.markNodeAssignments(parent) - } - } -} - -func (c *Checker) hasParentWithAssignmentsMarked(node *ast.Node) bool { - return ast.FindAncestor(node.Parent, func(node *ast.Node) bool { - return ast.IsFunctionOrSourceFile(node) && c.nodeLinks.Get(node).flags&NodeCheckFlagsAssignmentsMarked != 0 - }) != nil + c.assignmentsMarked.once(c, parent, func() { + c.markNodeAssignments(parent) + }) } // For all assignments within the given root node, record the last assignment source position for all diff --git a/tsc/internal/checker/grammarchecks.go b/tsc/internal/checker/grammarchecks.go index 7282241c8bcee..5ef5fd7775ff6 100644 --- a/tsc/internal/checker/grammarchecks.go +++ b/tsc/internal/checker/grammarchecks.go @@ -2026,24 +2026,21 @@ func (c *Checker) checkGrammarSourceFile(node *ast.SourceFile) bool { func (c *Checker) checkGrammarStatementInAmbientContext(node *ast.Node) bool { if node.Flags&ast.NodeFlagsAmbient != 0 { - // Find containing block which is either Block, ModuleBlock, SourceFile - links := c.nodeLinks.Get(node) - if !links.hasReportedStatementInAmbientContext && (ast.IsFunctionLike(node.Parent) || ast.IsAccessor(node.Parent)) { - links.hasReportedStatementInAmbientContext = c.grammarErrorOnFirstToken(node, diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts) - return links.hasReportedStatementInAmbientContext + if ast.IsFunctionLike(node.Parent) || ast.IsAccessor(node.Parent) { + return c.grammarErrorOnFirstToken(node, diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts) } // We are either parented by another statement, or some sort of block. - // If we're in a block, we only want to really report an error once - // to prevent noisiness. So use a bit on the block to indicate if - // this has already been reported, and don't report if it has. - // + // If we're in a block, only its first statement not allowed in an + // ambient context reports an error, to prevent noisiness, unless the + // block is the body of a function, which reports itself. if node.Parent.Kind == ast.KindBlock || node.Parent.Kind == ast.KindModuleBlock || node.Parent.Kind == ast.KindSourceFile { - links := c.nodeLinks.Get(node.Parent) - // Check if the containing block ever report this error - if !links.hasReportedStatementInAmbientContext { - links.hasReportedStatementInAmbientContext = c.grammarErrorOnFirstToken(node, diagnostics.Statements_are_not_allowed_in_ambient_contexts) - return links.hasReportedStatementInAmbientContext + block := node.Parent + if block.Kind == ast.KindBlock && (ast.IsFunctionLike(block.Parent) || ast.IsAccessor(block.Parent)) { + return false + } + if core.Find(block.Statements(), isStatementNotAllowedInAmbientContext) == node { + return c.grammarErrorOnFirstToken(node, diagnostics.Statements_are_not_allowed_in_ambient_contexts) } } else { // We must be parented by a statement. If so, there's no need @@ -2054,6 +2051,23 @@ func (c *Checker) checkGrammarStatementInAmbientContext(node *ast.Node) bool { return false } +// isStatementNotAllowedInAmbientContext reports whether the check of node +// reports it with checkGrammarStatementInAmbientContext. +func isStatementNotAllowedInAmbientContext(node *ast.Node) bool { + if node.Flags&ast.NodeFlagsAmbient == 0 { + return false + } + switch node.Kind { + case ast.KindBlock, ast.KindEmptyStatement, ast.KindDebuggerStatement, ast.KindExpressionStatement, + ast.KindIfStatement, ast.KindDoStatement, ast.KindWhileStatement, ast.KindForStatement, + ast.KindForInStatement, ast.KindForOfStatement, ast.KindBreakStatement, ast.KindContinueStatement, + ast.KindReturnStatement, ast.KindWithStatement, ast.KindSwitchStatement, ast.KindLabeledStatement, + ast.KindThrowStatement, ast.KindTryStatement: + return true + } + return false +} + func (c *Checker) checkGrammarNumericLiteral(node *ast.NumericLiteral) { nodeText := scanner.GetTextOfNode(node.AsNode()) diff --git a/tsc/internal/checker/inference.go b/tsc/internal/checker/inference.go index 8b0cc87aedef4..cd10d3e3c469e 100644 --- a/tsc/internal/checker/inference.go +++ b/tsc/internal/checker/inference.go @@ -399,7 +399,7 @@ func (c *Checker) inferFromMatchingTypes(n *InferenceState, sources []*Type, tar // when inferring from string[] | string[][] to T[] | T[][], the inference of string we make from // relating string[][] to T[][] is of higher quality than the inference of string[] we make relating // string[][] to T[]. - slices.SortFunc(matchedTargets, compareTypesAndDepth) + slices.SortFunc(matchedTargets, c.compareTypesAndDepth) for _, t := range matchedTargets { for _, s := range matchedSources { if matches(c, s, t) { @@ -418,9 +418,9 @@ func (c *Checker) inferFromMatchingTypes(n *InferenceState, sources []*Type, tar } // Compare two types first by depth and then by the regular type ordering. -func compareTypesAndDepth(t1, t2 *Type) int { - d1 := getTypeDepth(t1, 3) - d2 := getTypeDepth(t2, 3) +func (c *Checker) compareTypesAndDepth(t1, t2 *Type) int { + d1 := c.getTypeDepth(t1, 3) + d2 := c.getTypeDepth(t2, 3) if d1 != d2 { return d2 - d1 // Largest depth sorts first } @@ -431,27 +431,27 @@ func compareTypesAndDepth(t1, t2 *Type) int { // and type references, the depth is one plus the largest type argument depth. For union and // intersection types, the depth is the largest constituent type depth. For all other types, // the depth is zero. The maximum depth limits infinite recursion of circular types. -func getTypeDepth(t *Type, maxDepth int) int { +func (c *Checker) getTypeDepth(t *Type, maxDepth int) int { if maxDepth != 0 { if t.alias != nil && len(t.alias.typeArguments) != 0 { - return getTypeListDepth(t.alias.typeArguments, maxDepth-1) + 1 + return c.getTypeListDepth(t.alias.typeArguments, maxDepth-1) + 1 } if t.objectFlags&ObjectFlagsReference != 0 { - if typeArguments := t.checker.getTypeArguments(t); len(typeArguments) != 0 { - return getTypeListDepth(typeArguments, maxDepth-1) + 1 + if typeArguments := c.getTypeArguments(t); len(typeArguments) != 0 { + return c.getTypeListDepth(typeArguments, maxDepth-1) + 1 } } if t.flags&TypeFlagsUnionOrIntersection != 0 { - return getTypeListDepth(t.Types(), maxDepth) + return c.getTypeListDepth(t.Types(), maxDepth) } } return 0 } -func getTypeListDepth(types []*Type, maxDepth int) int { +func (c *Checker) getTypeListDepth(types []*Type, maxDepth int) int { depth := 0 for _, t := range types { - depth = max(depth, getTypeDepth(t, maxDepth)) + depth = max(depth, c.getTypeDepth(t, maxDepth)) } return depth } @@ -984,7 +984,7 @@ func (c *Checker) inferToMappedType(n *InferenceState, source *Type, target *Typ if constraintType.flags&TypeFlagsTypeParameter != 0 { // We're inferring from some source type S to a mapped type { [P in K]: X }, where K is a type // parameter. First infer from 'keyof S' to K. - c.inferWithPriority(n, c.getIndexTypeEx(source, core.IfElse(c.patternForType[source] != nil, IndexFlagsNoIndexSignatures, IndexFlagsNone)), constraintType, InferencePriorityMappedTypeConstraint) + c.inferWithPriority(n, c.getIndexTypeEx(source, core.IfElse(c.patternForType.has(source), IndexFlagsNoIndexSignatures, IndexFlagsNone)), constraintType, InferencePriorityMappedTypeConstraint) // If K is constrained to a type C, also infer to C. Thus, for a mapped type { [P in K]: X }, // where K extends keyof T, we make the same inferences as for a homomorphic mapped type // { [P in keyof T]: X }. This enables us to make meaningful inferences when the target is a @@ -1014,11 +1014,13 @@ func (c *Checker) inferToMappedType(n *InferenceState, source *Type, target *Typ // variable T[P] (i.e. we treat the type T[P] as the type variable we're inferring for). func (c *Checker) inferTypeForHomomorphicMappedType(source *Type, target *Type, constraint *Type) *Type { key := ReverseMappedTypeKey{sourceId: source.id, targetId: target.id, constraintId: constraint.id} - if cached := c.reverseHomomorphicMappedCache[key]; cached != nil { + if cached, _ := c.reverseHomomorphicMappedCache.cached(c, key); cached != nil { return cached } + c.reverseHomomorphicMappedCache.begin(c, key) t := c.createReverseMappedType(source, target, constraint) - c.reverseHomomorphicMappedCache[key] = t + c.reverseHomomorphicMappedCache.set(c, key, t) + c.endMemo() return t } @@ -1076,9 +1078,13 @@ func (c *Checker) isPartiallyInferableType(t *Type) bool { func (c *Checker) inferReverseMappedType(source *Type, target *Type, constraint *Type) *Type { key := ReverseMappedTypeKey{sourceId: source.id, targetId: target.id, constraintId: constraint.id} - if cached, ok := c.reverseMappedCache[key]; ok { + if cached, ok := c.reverseMappedCache.cached(c, key); ok { return core.OrElse(cached, c.unknownType) } + c.reverseMappedCache.begin(c, key) + if len(c.reverseMappedSourceStack) == 0 { + c.reverseMappedStart = int32(len(c.resolutions) - 1) + } c.reverseMappedSourceStack = append(c.reverseMappedSourceStack, source) c.reverseMappedTargetStack = append(c.reverseMappedTargetStack, target) saveExpandingFlags := c.reverseExpandingFlags @@ -1091,11 +1097,19 @@ func (c *Checker) inferReverseMappedType(source *Type, target *Type, constraint var t *Type if c.reverseExpandingFlags != ExpandingFlagsBoth { t = c.inferReverseMappedTypeWorker(source, target, constraint) + } else { + // Stopping depends on the enclosing reverse mappings, not just on key, so + // only the outermost one, which has none, may keep a result. + c.markCircular(int(c.reverseMappedStart)) } c.reverseMappedSourceStack = c.reverseMappedSourceStack[:len(c.reverseMappedSourceStack)-1] c.reverseMappedTargetStack = c.reverseMappedTargetStack[:len(c.reverseMappedTargetStack)-1] + if len(c.reverseMappedSourceStack) == 0 { + c.reverseMappedStart = 0 + } c.reverseExpandingFlags = saveExpandingFlags - c.reverseMappedCache[key] = t + c.reverseMappedCache.set(c, key, t) + c.endMemo() return t } @@ -1155,16 +1169,16 @@ func (c *Checker) resolveReverseMappedTypeMembers(t *Type) { } members.Set(prop.Name(), inferredProp) } - c.setStructuredTypeMembers(t, members, nil, nil, indexInfos) + c.setStructuredTypeData(t, members, nil, nil, indexInfos) } func (c *Checker) getTypeOfReverseMappedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { reverseLinks := c.ReverseMappedSymbolLinks.Get(symbol) - links.resolvedType = core.OrElse(c.inferReverseMappedType(reverseLinks.propertyType, reverseLinks.mappedType, reverseLinks.constraintType), c.unknownType) + links.resolvedType.set(c, core.OrElse(c.inferReverseMappedType(reverseLinks.propertyType, reverseLinks.mappedType, reverseLinks.constraintType), c.unknownType)) } - return links.resolvedType + return links.resolvedType.cached(c) } // If the original mapped type had an intersection constraint we extract its components, @@ -1250,7 +1264,7 @@ func (c *Checker) createEmptyObjectTypeFromStringLiteral(t *Type) *Type { } name := getStringLiteralValue(t) literalProp := c.newSymbol(ast.SymbolFlagsProperty, name) - c.valueSymbolLinks.Get(literalProp).resolvedType = c.anyType + c.valueSymbolLinks.Get(literalProp).resolvedType.setIdentity(c, c.anyType) if t.symbol != nil { literalProp.SetDeclarations(t.symbol.Declarations()) literalProp.SetValueDeclaration(t.symbol.ValueDeclaration()) @@ -1637,7 +1651,7 @@ func (c *Checker) isFromInferenceBlockedSource(t *Type) bool { } func (c *Checker) isSkipDirectInferenceNode(node *ast.Node) bool { - return c.skipDirectInferenceNodes.Has(node) + return c.request != nil && c.request.skipDirectInferenceNodes.Has(node) } func newInferenceInfo(typeParameter *Type) *InferenceInfo { diff --git a/tsc/internal/checker/jsx.go b/tsc/internal/checker/jsx.go index 1054f4d46f8c5..b8c37cdd49d98 100644 --- a/tsc/internal/checker/jsx.go +++ b/tsc/internal/checker/jsx.go @@ -32,11 +32,11 @@ const ( ) type JsxElementLinks struct { - jsxFlags JsxFlags // Flags for the JSX element - resolvedJsxElementAttributesType *Type // Resolved element attributes type of a JSX opening-like element - jsxNamespace *ast.Symbol // Resolved JSX namespace symbol for this node - jsxImplicitImportContainer *ast.Symbol // Resolved module symbol the implicit JSX import of this file should refer to - firstJSXTagInFile *ast.Node // The first JSX tag in the file + jsxFlags JsxFlags // Flags for the JSX element + resolvedJsxElementAttributesType memo[*Type] // Resolved element attributes type of a JSX opening-like element + jsxNamespace memo[*ast.Symbol] // Resolved JSX namespace symbol for this node + jsxImplicitImportContainer *ast.Symbol // Resolved module symbol the implicit JSX import of this file should refer to + firstJSXTagInFile *ast.Node // The first JSX tag in the file } var JsxNames = struct { @@ -265,9 +265,10 @@ func (c *Checker) getContextualTypeForChildJsxExpression(node *ast.Node, child * func (c *Checker) discriminateContextualTypeByJSXAttributes(node *ast.Node, contextualType *Type) *Type { key := DiscriminatedContextualTypeKey{nodeId: ast.GetNodeId(node), typeId: contextualType.id} - if discriminated := c.discriminatedContextualTypes[key]; discriminated != nil { + if discriminated, _ := c.discriminatedContextualTypes.cached(c, key); discriminated != nil { return discriminated } + c.discriminatedContextualTypes.begin(c, key) jsxChildrenPropertyName := c.getJsxElementChildrenPropertyName(c.getJsxNamespaceAt(node)) discriminantProperties := core.Filter(node.Properties(), func(p *ast.Node) bool { symbol := p.Symbol() @@ -289,7 +290,8 @@ func (c *Checker) discriminateContextualTypeByJSXAttributes(node *ast.Node, cont }) discriminator := &ObjectLiteralDiscriminator{c: c, props: discriminantProperties, members: discriminantMembers} discriminated := c.discriminateTypeByDiscriminableItems(contextualType, discriminator) - c.discriminatedContextualTypes[key] = discriminated + c.discriminatedContextualTypes.set(c, key, discriminated) + c.endMemo() return discriminated } @@ -500,15 +502,22 @@ func (c *Checker) getSuggestedSymbolForNonexistentJSXAttribute(name string, cont func (c *Checker) getJSXFragmentType(node *ast.Node) *Type { // An opening fragment is required in order for `getJsxNamespace` to give the fragment factory links := c.sourceFileLinks.Get(ast.GetSourceFileOfNode(node)) - if links.jsxFragmentType != nil { - return links.jsxFragmentType + if t := links.jsxFragmentType.cached(c); t != nil { + return t } + links.jsxFragmentType.begin(c) + t := c.getJSXFragmentTypeUncached(node) + links.jsxFragmentType.set(c, t) + c.endMemo() + return t +} + +func (c *Checker) getJSXFragmentTypeUncached(node *ast.Node) *Type { jsxFragmentFactoryName := c.getJsxNamespace(node) // #38720/60122, allow null as jsxFragmentFactory shouldResolveFactoryReference := (c.compilerOptions.Jsx == core.JsxEmitReact || c.compilerOptions.JsxFragmentFactory != "") && jsxFragmentFactoryName != "null" if !shouldResolveFactoryReference { - links.jsxFragmentType = c.anyType - return links.jsxFragmentType + return c.anyType } jsxFactorySymbol := c.getJsxNamespaceContainerForImplicitImport(node) if jsxFactorySymbol == nil { @@ -520,12 +529,10 @@ func (c *Checker) getJSXFragmentType(node *ast.Node) *Type { jsxFactorySymbol = c.resolveName(node, jsxFragmentFactoryName, flags, diagnostics.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found, true /*isUse*/, false /*excludeGlobals*/) } if jsxFactorySymbol == nil { - links.jsxFragmentType = c.errorType - return links.jsxFragmentType + return c.errorType } if jsxFactorySymbol.Name() == ReactNames.Fragment { - links.jsxFragmentType = c.getTypeOfSymbol(jsxFactorySymbol) - return links.jsxFragmentType + return c.getTypeOfSymbol(jsxFactorySymbol) } resolvedAlias := jsxFactorySymbol if jsxFactorySymbol.Flags()&ast.SymbolFlagsAlias != 0 { @@ -535,11 +542,9 @@ func (c *Checker) getJSXFragmentType(node *ast.Node) *Type { reactExports := c.getExportsOfSymbol(resolvedAlias) typeSymbol := c.getSymbol(reactExports, ReactNames.Fragment, ast.SymbolFlagsBlockScopedVariable) if typeSymbol != nil { - links.jsxFragmentType = c.getTypeOfSymbol(typeSymbol) - } else { - links.jsxFragmentType = c.errorType + return c.getTypeOfSymbol(typeSymbol) } - return links.jsxFragmentType + return c.errorType } func (c *Checker) resolveJsxOpeningLikeElement(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { @@ -748,7 +753,7 @@ func (c *Checker) createJsxAttributesTypeFromAttributesProperty(openingLikeEleme attributeSymbol.SetValueDeclaration(member.ValueDeclaration()) } links := c.valueSymbolLinks.Get(attributeSymbol) - links.resolvedType = exprType + links.resolvedType.setIdentity(c, exprType) links.target = member attributesTable.Set(attributeSymbol.Name(), attributeSymbol) if allAttributesTable != nil { @@ -836,11 +841,11 @@ func (c *Checker) createJsxAttributesTypeFromAttributesProperty(openingLikeEleme links := c.valueSymbolLinks.Get(childrenPropSymbol) switch { case len(childTypes) == 1: - links.resolvedType = childTypes[0] + links.resolvedType.setIdentity(c, childTypes[0]) case childrenContextualType != nil && someType(childrenContextualType, c.isTupleLikeType): - links.resolvedType = c.createTupleType(childTypes) + links.resolvedType.setIdentity(c, c.createTupleType(childTypes)) default: - links.resolvedType = c.createArrayType(c.getUnionType(childTypes)) + links.resolvedType.setIdentity(c, c.createArrayType(c.getUnionType(childTypes))) } // Fake up a property declaration for the children childrenPropSymbol.SetValueDeclaration(c.factory.NewPropertySignatureDeclaration(nil, c.factory.NewIdentifier(jsxChildrenPropertyName), nil /*postfixToken*/, nil /*type*/, nil /*initializer*/)) @@ -1178,7 +1183,7 @@ func (c *Checker) createSignatureForJSXIntrinsic(node *ast.Node, result *Type) * // returnNode := typeSymbol && c.nodeBuilder.symbolToEntityName(typeSymbol, ast.SymbolFlagsType, node) // declaration := factory.createFunctionTypeNode(nil, []ParameterDeclaration{factory.createParameterDeclaration(nil, nil /*dotDotDotToken*/, "props", nil /*questionToken*/, c.nodeBuilder.typeToTypeNode(result, node))}, ifElse(returnNode != nil, factory.createTypeReferenceNode(returnNode, nil /*typeArguments*/), factory.createKeywordTypeNode(ast.KindAnyKeyword))) parameterSymbol := c.newSymbol(ast.SymbolFlagsFunctionScopedVariable, "props") - c.valueSymbolLinks.Get(parameterSymbol).resolvedType = result + c.valueSymbolLinks.Get(parameterSymbol).resolvedType.setIdentity(c, result) return c.newSignature(SignatureFlagsNone, nil, nil, nil, []*ast.Symbol{parameterSymbol}, elementType, nil, 1) } @@ -1188,23 +1193,31 @@ func (c *Checker) createSignatureForJSXIntrinsic(node *ast.Node, result *Type) * func (c *Checker) getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node *ast.Node) *Type { debug.Assert(isJsxIntrinsicTagName(node.TagName())) links := c.jsxElementLinks.Get(node) - if links.resolvedJsxElementAttributesType != nil { - return links.resolvedJsxElementAttributesType + if t := links.resolvedJsxElementAttributesType.cached(c); t != nil { + return t } + links.resolvedJsxElementAttributesType.begin(c) + result := c.getIntrinsicAttributesTypeFromJsxOpeningLikeElementUncached(node, links) + c.endMemo() + return result +} + +func (c *Checker) getIntrinsicAttributesTypeFromJsxOpeningLikeElementUncached(node *ast.Node, links *JsxElementLinks) *Type { + if t := links.resolvedJsxElementAttributesType.cached(c); t != nil { + return t + } + result := c.errorType symbol := c.getIntrinsicTagSymbol(node) if links.jsxFlags&JsxFlagsIntrinsicNamedElement != 0 { - links.resolvedJsxElementAttributesType = core.OrElse(c.getTypeOfSymbol(symbol), c.errorType) - return links.resolvedJsxElementAttributesType - } - if links.jsxFlags&JsxFlagsIntrinsicIndexedElement != 0 { + result = core.OrElse(c.getTypeOfSymbol(symbol), c.errorType) + } else if links.jsxFlags&JsxFlagsIntrinsicIndexedElement != 0 { indexInfo := c.getApplicableIndexInfoForName(c.getJsxType(JsxNames.IntrinsicElements, node), node.TagName().Text()) if indexInfo != nil { - links.resolvedJsxElementAttributesType = indexInfo.valueType - return links.resolvedJsxElementAttributesType + result = indexInfo.valueType } } - links.resolvedJsxElementAttributesType = c.errorType - return links.resolvedJsxElementAttributesType + links.resolvedJsxElementAttributesType.set(c, result) + return result } // Looks up an intrinsic tag name and returns a symbol that either points to an intrinsic @@ -1212,9 +1225,22 @@ func (c *Checker) getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node *ast. // string index signature (in which case nodeLinks.jsxFlags will be IntrinsicIndexedElement). // May also return unknownSymbol if both of these lookups fail. func (c *Checker) getIntrinsicTagSymbol(node *ast.Node) *ast.Symbol { + c.symbolNodeLinks.Get(node).resolvedSymbol.begin(c) + result := c.getIntrinsicTagSymbolUncached(node) + c.endMemo() + return result +} + +// setIntrinsicJsxFlag records how the intrinsic tag symbol of node was found, +// as part of resolving that symbol. +func (c *Checker) setIntrinsicJsxFlag(node *ast.Node, links *SymbolNodeLinks, flag JsxFlags) { + setFlagMemoBits(c, links.resolvedSymbol.key(), &c.jsxElementLinks.Get(node).jsxFlags, JsxFlagsIntrinsicNamedElement|JsxFlagsIntrinsicIndexedElement, flag) +} + +func (c *Checker) getIntrinsicTagSymbolUncached(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol != nil { - return links.resolvedSymbol + if links.resolvedSymbol.cached(c) != nil { + return links.resolvedSymbol.cached(c) } intrinsicElementsType := c.getJsxType(JsxNames.IntrinsicElements, node) if !c.isErrorType(intrinsicElementsType) { @@ -1226,32 +1252,32 @@ func (c *Checker) getIntrinsicTagSymbol(node *ast.Node) *ast.Symbol { propName := tagName.Text() intrinsicProp := c.getPropertyOfType(intrinsicElementsType, propName) if intrinsicProp != nil { - c.jsxElementLinks.Get(node).jsxFlags |= JsxFlagsIntrinsicNamedElement - links.resolvedSymbol = intrinsicProp - return links.resolvedSymbol + c.setIntrinsicJsxFlag(node, links, JsxFlagsIntrinsicNamedElement) + links.resolvedSymbol.set(c, intrinsicProp) + return links.resolvedSymbol.cached(c) } // Intrinsic string indexer case indexSymbol := c.getApplicableIndexSymbol(intrinsicElementsType, c.getStringLiteralType(propName)) if indexSymbol != nil { - c.jsxElementLinks.Get(node).jsxFlags |= JsxFlagsIntrinsicIndexedElement - links.resolvedSymbol = indexSymbol - return links.resolvedSymbol + c.setIntrinsicJsxFlag(node, links, JsxFlagsIntrinsicIndexedElement) + links.resolvedSymbol.set(c, indexSymbol) + return links.resolvedSymbol.cached(c) } if c.getTypeOfPropertyOrIndexSignatureOfType(intrinsicElementsType, propName) != nil { - c.jsxElementLinks.Get(node).jsxFlags |= JsxFlagsIntrinsicIndexedElement - links.resolvedSymbol = intrinsicElementsType.symbol - return links.resolvedSymbol + c.setIntrinsicJsxFlag(node, links, JsxFlagsIntrinsicIndexedElement) + links.resolvedSymbol.set(c, intrinsicElementsType.symbol) + return links.resolvedSymbol.cached(c) } // Wasn't found c.error(node, diagnostics.Property_0_does_not_exist_on_type_1, tagName.Text(), "JSX."+JsxNames.IntrinsicElements) - links.resolvedSymbol = c.unknownSymbol - return links.resolvedSymbol + links.resolvedSymbol.set(c, c.unknownSymbol) + return links.resolvedSymbol.cached(c) } if c.noImplicitAny { c.error(node, diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, JsxNames.IntrinsicElements) } - links.resolvedSymbol = c.unknownSymbol - return links.resolvedSymbol + links.resolvedSymbol.set(c, c.unknownSymbol) + return links.resolvedSymbol.cached(c) } func (c *Checker) getJsxStatelessElementTypeAt(location *ast.Node) *Type { @@ -1302,14 +1328,28 @@ func (c *Checker) getJsxType(name string, location *ast.Node) *Type { } func (c *Checker) getJsxNamespaceAt(location *ast.Node) *ast.Symbol { - var links *JsxElementLinks - if location != nil { - links = c.jsxElementLinks.Get(location) + if location == nil { + return c.getJsxNamespaceAtUncached(location, nil) } - if links != nil && links.jsxNamespace != nil && links.jsxNamespace != c.unknownSymbol { - return links.jsxNamespace + links := c.jsxElementLinks.Get(location) + if s := links.jsxNamespace.cached(c); s != nil && s != c.unknownSymbol { + return s } - if links == nil || links.jsxNamespace != c.unknownSymbol { + links.jsxNamespace.begin(c) + result := c.getJsxNamespaceAtUncached(location, links) + c.endMemo() + return result +} + +func (c *Checker) getJsxNamespaceAtUncached(location *ast.Node, links *JsxElementLinks) *ast.Symbol { + var cached *ast.Symbol + if links != nil { + cached = links.jsxNamespace.cached(c) + if cached != nil && cached != c.unknownSymbol { + return cached + } + } + if cached != c.unknownSymbol { resolvedNamespace := c.getJsxNamespaceContainerForImplicitImport(location) if resolvedNamespace == nil || resolvedNamespace == c.unknownSymbol { namespaceName := c.getJsxNamespace(location) @@ -1319,13 +1359,13 @@ func (c *Checker) getJsxNamespaceAt(location *ast.Node) *ast.Symbol { candidate := c.resolveSymbol(c.getSymbol(c.getExportsOfSymbol(c.resolveSymbol(resolvedNamespace)), JsxNames.JSX, ast.SymbolFlagsNamespace)) if candidate != nil && candidate != c.unknownSymbol { if links != nil { - links.jsxNamespace = candidate + links.jsxNamespace.set(c, candidate) } return candidate } } if links != nil { - links.jsxNamespace = c.unknownSymbol + links.jsxNamespace.set(c, c.unknownSymbol) } } // JSX global fallback @@ -1450,8 +1490,16 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node) file := ast.GetSourceFileOfNode(location) links := c.jsxElementLinks.Get(file.AsNode()) if links.jsxImplicitImportContainer != nil { + c.observeFlagMemo(memoKeyOf(links, memoJsxImplicitImportContainer)) return core.IfElse(links.jsxImplicitImportContainer == c.unknownSymbol, nil, links.jsxImplicitImportContainer) } + c.beginMemo(memoKeyOf(links, memoJsxImplicitImportContainer)) + result := c.getJsxNamespaceContainerForImplicitImportUncached(file, links) + c.endMemo() + return result +} + +func (c *Checker) getJsxNamespaceContainerForImplicitImportUncached(file *ast.SourceFile, links *JsxElementLinks) *ast.Symbol { canonicalErrorTag := links.firstJSXTagInFile if canonicalErrorTag == nil { var visit ast.Visitor @@ -1479,7 +1527,7 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node) if mod != nil && mod != c.unknownSymbol { result = c.getMergedSymbol(c.resolveSymbol(mod)) } - links.jsxImplicitImportContainer = core.OrElse(result, c.unknownSymbol) + c.setFlagMemoValue(memoKeyOf(links, memoJsxImplicitImportContainer), &links.jsxImplicitImportContainer, core.OrElse(result, c.unknownSymbol)) return result } diff --git a/tsc/internal/checker/links.go b/tsc/internal/checker/links.go index c21981cae9d80..e7a92438685bf 100644 --- a/tsc/internal/checker/links.go +++ b/tsc/internal/checker/links.go @@ -31,8 +31,13 @@ func (s *nodeLinkStore[V]) Has(node *ast.Node) bool { return s.TryGet(node) != nil } +// TryGet returns the links of node, or nil if it has none. A node without +// an id has no links, and looking it up does not give it one. func (s *nodeLinkStore[V]) TryGet(node *ast.Node) *V { - id := uint64(s.gen.GetNodeId(node)) + id := uint64(ast.PeekNodeId(node)) + if id == 0 { + return nil + } if id >= ast.BlockIdOffset && id < ast.BlockIdOffset+maxPageLinkCount { return s.pages.TryGet(id - ast.BlockIdOffset) } @@ -57,8 +62,13 @@ func (s *symbolLinkStore[V]) Has(symbol *ast.Symbol) bool { return s.TryGet(symbol) != nil } +// TryGet returns the links of symbol, or nil if it has none. A symbol +// without an id has no links, and looking it up does not give it one. func (s *symbolLinkStore[V]) TryGet(symbol *ast.Symbol) *V { - id := uint64(s.gen.GetSymbolId(symbol)) + id := uint64(ast.PeekSymbolId(symbol)) + if id == 0 { + return nil + } if id >= ast.BlockIdOffset && id < ast.BlockIdOffset+maxPageLinkCount { return s.pages.TryGet(id - ast.BlockIdOffset) } diff --git a/tsc/internal/checker/markwrites_test.go b/tsc/internal/checker/markwrites_test.go new file mode 100644 index 0000000000000..f975da6772f5c --- /dev/null +++ b/tsc/internal/checker/markwrites_test.go @@ -0,0 +1,97 @@ +package checker_test + +import ( + goast "go/ast" + "go/parser" + "go/token" + "path/filepath" + "strings" + "testing" + + "gotest.tools/v3/assert" +) + +// markFields are fields holding what checking accumulates for later checks +// and emit to read, such as which symbols are referenced or which nodes are +// checked once a file is: a computation answering a query must not write +// them, or what checking reports depends on what was asked first (see +// writesMarks). +var markFields = map[string]bool{ + "referenceKinds": true, + "referenced": true, + "deferredNodes": true, + "identifierCheckNodes": true, + "externalHelperRequests": true, + "requestedExternalEmitHelpers": true, + "nonExistentPropertyNodes": true, + "deferredDiagnosticCallbacks": true, +} + +// Marks may only be written by functions that test whether they may be, +// which record them as an effect otherwise, or by those listed in +// allowedMarkWriters with the reason they only run when checking. +func TestMarksAreWrittenOnlyWhenChecking(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + seen := make(map[string]bool) + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + guarded := false + goast.Inspect(fn.Body, func(n goast.Node) bool { + if sel, ok := n.(*goast.SelectorExpr); ok && (sel.Sel.Name == "writesMarks" || sel.Sel.Name == "checking") { + guarded = true + } + return !guarded + }) + check := func(pos token.Pos, e goast.Expr) { + sel, ok := e.(*goast.SelectorExpr) + if !ok || !markFields[sel.Sel.Name] { + return + } + key := fn.Name.Name + ": " + sel.Sel.Name + seen[key] = true + if _, ok := allowedMarkWriters[key]; !ok && !guarded { + t.Errorf("%s: %s writes %s without testing whether checking may", fset.Position(pos), fn.Name.Name, sel.Sel.Name) + } + } + goast.Inspect(fn.Body, func(n goast.Node) bool { + switch n := n.(type) { + case *goast.AssignStmt: + for _, lhs := range n.Lhs { + check(n.Pos(), lhs) + } + case *goast.CallExpr: + if sel, ok := n.Fun.(*goast.SelectorExpr); ok && (sel.Sel.Name == "Add" || sel.Sel.Name == "Delete" || sel.Sel.Name == "Clear") { + check(n.Pos(), sel.X) + } + } + return true + }) + } + } + for key := range allowedMarkWriters { + if !seen[key] { + t.Errorf("allowedMarkWriters lists %s, which writes no mark", key) + } + } +} + +// allowedMarkWriters lists functions writing marks without testing, keyed by +// function and field, with why they only run when checking. +var allowedMarkWriters = map[string]string{ + "checkDeferredNodes: deferredNodes": "called by checkSourceFileWorker", + "checkExternalHelperRequests: externalHelperRequests": "called by checkSourceFileWorker", + "produceDeferredDiagnostics: deferredDiagnosticCallbacks": "called by checkSourceFileWorker", + "checkExternalEmitHelpersAt: requestedExternalEmitHelpers": "called by checkExternalEmitHelpers once it may write, and checkExternalHelperRequests", +} diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go new file mode 100644 index 0000000000000..debda5aebc60c --- /dev/null +++ b/tsc/internal/checker/memo.go @@ -0,0 +1,2304 @@ +package checker + +import ( + "hash/maphash" + "iter" + "maps" + "math" + "math/bits" + "slices" + "unsafe" + + "github.com/microsoft/TypeScript/tsc/internal/ast" + + "github.com/microsoft/TypeScript/tsc/internal/debug" + "github.com/microsoft/TypeScript/tsc/internal/diagnostics" +) + +// Checker side effects and memoization +// +// Checking a file produces outputs other than types: diagnostics, reference +// marks used by unused-identifier checks, deferred nodes, and so on. Those +// outputs are produced while computing memoized results (the type of a symbol, +// the resolved symbol of an identifier, ...). If such a result is first computed +// for an API query rather than while checking, a later check reuses the cached +// result without recomputing it, so the outputs would historically either leak +// (reported for code that checking never visits) or be lost (never reported for +// code that checking does visit). Both make diagnostics depend on query history. +// +// To make checking independent of query history, a checker is either checking +// or answering queries. A query does not apply side effects. Instead it +// records them against the innermost memoized computation in progress, along +// with the memoized results that computation reused. When a check later +// reuses a memoized result, it replays the recorded effects of that result +// and everything it transitively reused, exactly as if it had computed the +// result itself. Effects produced outside any memoized computation belong +// solely to the query and are discarded. A check applies its own effects as +// they happen, except while results it computes may be discarded, when it +// records them as a query does (see recordFromCheck). + +type memoField uint8 + +const ( + memoCell memoField = iota // A memo[T], keyed by its own address + memoWriteType + memoDeclaredType + memoTypeNodeType + memoBaseTypes + memoStructuredMembers + memoTypeParameterConstraint + memoTypeParameterDefault + memoEnumMemberValue + memoBaseConstraint + memoAccessorType + memoContextualParameters + memoContextChecked + memoInitializerIsUndefined + memoFlowExpressionType + memoFlowLoopType + memoJsxImplicitImportContainer + memoModuleExports + memoInstantiationExpressionType + memoTypePredicate + memoDeclaredMembers + memoCouldContainTypeVariables + memoGenericObjectFlags + memoUnknownLikeUnion + memoNeverIntersection + memoDiscriminant + memoMapEntry // An entry of a memoMap; see memoMap.entryKey + memoResolvedMembers // followed by one field per MembersOrExportsResolutionKind + memoSymbolExports = memoResolvedMembers + memoField(MembersOrExportsResolutionKindResolvedExports) + memoSymbolMembers = memoResolvedMembers + memoField(MembersOrExportsResolutionKindResolvedMembers) + memoFieldCount = memoResolvedMembers + 2 +) + +// A reentry says what it means to re-enter a computation in progress, which +// can only observe whatever the computation has published so far. +type reentry uint8 + +const ( + // What re-entry observes is incomplete, so the results computed while + // the outer computation is in progress are discarded when it finishes, + // and computed again from its result. This is the default. + reentryCircular reentry = iota + // The computation detects re-entry with a type resolution of its own, + // which decides the head of the cycle and what to discard. + reentryResolution + // Re-entry observes the partial result the computation has published so + // far, or computes the result again if it publishes none. Results + // derived from it may differ depending on which computation starts + // first. Like re-entering a circular computation, it reads an incomplete + // result; see markReadIncomplete. + reentryPartial +) + +// reenter accounts for re-entering the computation in progress at index i +// of resolutions, as r says. +func (c *Checker) reenter(i int, r reentry) { + if r == reentryCircular { + c.markCircular(i) + } + if r != reentryResolution { + c.markReadIncomplete(i) + } +} + +// memoReentry says what re-entering means for each kind of computation. +var memoReentry = [memoFieldCount]reentry{ + // memoCompute keeps the result that a re-entrant computation cached, + // and many cells publish an in-progress marker for re-entry to read. + memoCell: reentryPartial, + // Many kinds of types make members available before they are complete. + memoStructuredMembers: reentryPartial, + // Circular defaults are reported at the default first in program order. + memoTypeParameterDefault: reentryResolution, + // Contextual parameter typing resolves a cycle through the enclosing call. + // Its type resolution ends once the parameters are assigned. + memoContextualParameters: reentryResolution, +} + +// memoKey identifies a memoized result: the address of the entity owning the +// cache slot (an *ast.Node, *ast.Symbol, *Type, or *Signature) shifted left by +// eight bits, plus the memoField of the slot. Packing into an integer keeps map +// operations on the fast path. Entities live as long as the program or the +// checker store, so an address cannot be reused while its keys exist. +type memoKey uint64 + +func (k memoKey) field() memoField { + return memoField(k) +} + +func memoKeyOf[T any](entity *T, field memoField) memoKey { + // SAFETY: Only the address is kept, as an identity; it is never turned back + // into a pointer. + return memoKey(uint64(uintptr(unsafe.Pointer(entity)))<<8 | uint64(field)) +} + +type memoEffects struct { + effects []func(c *Checker) + deps []*memoEffects + parent *memoEffects // Resolution d was most recently added to; avoids duplicate deps + entry *ast.Node // Current node when the computation started, if entered + rare *memoEffectsRare + entered bool // Whether this is the resolution of a computation, not just a set of deps + // Whether the result was discarded at the end of a cycle, so that its + // own effects are not replayed; see effectsToDrop. + dropped bool +} + +// memoEffectsRare holds the parts of memoEffects that few computations have, +// kept apart since the effects of every computation in a program can be +// retained at once. +type memoEffectsRare struct { + cycles []memoCycleDep // The cycle heads memoCycle added to deps, from highest to lowest + // Marks the computation recorded (see writesMarks), replayed even if its + // effects are dropped: that the computation reached what it marks does + // not depend on what it read. + marks []func(c *Checker) +} + +func (f *memoEffects) rareFields() *memoEffectsRare { + if f.rare == nil { + f.rare = &memoEffectsRare{} + } + return f.rare +} + +func (f *memoEffects) addDep(d *memoEffects) { + if f == d || d.parent == f { + return + } + d.parent = f + f.deps = append(f.deps, d) +} + +// covers reports whether replaying f replays deps, checking only the direct +// dependencies of f, and only of a few, to stay cheap. +func (f *memoEffects) covers(deps []*memoEffects) bool { + if len(deps) > 16 || len(f.deps) > 64 { + return false + } + for _, d := range deps { + if d != f && !slices.Contains(f.deps, d) { + return false + } + } + return true +} + +// memoState is the memo state of one memoized result. +type memoState struct { + pending *memoEffects // Effects not yet replayed by a check + errors *[]*currentNodeError // Errors the computation reported at the current node, out of line since few have any; see setErrors +} + +// memo is a cached result. Cached checker state must live in a memo so that +// every read accounts for the effects of the computation that produced it; +// see the package comment above. The value is only accessible through +// methods. The memo state of a result is kept in the store's memo state map, +// keyed by the address of the memo, so a memo costs nothing beyond its value. +type memo[T any] struct { + memoHeader + memoValue T +} + +// memoHeader is the part of a memo independent of its type, which identifies +// it. +type memoHeader struct { + _ memoNoCopy +} + +// memoNoCopy makes go vet reject copies of a memo, which would bypass it. +type memoNoCopy struct{} + +func (*memoNoCopy) Lock() {} +func (*memoNoCopy) Unlock() {} + +func (h *memoHeader) key() memoKey { + return memoKeyOf(h, memoCell) +} + +// cached returns the cached result, accounting for the effects of computing it. +func (m *memo[T]) cached(c *Checker) T { + if c.observing() { + c.observeCell(&m.memoHeader) + } + return m.memoValue +} + +// set caches a result. When set outside the result's own computation (for +// example, the types of binding elements assigned while resolving the type of +// their declaration), the result depends on the computation setting it. +func (m *memo[T]) set(c *Checker, v T) { + if c.logResults() { + m.logDiscard(c) + } + m.memoValue = v + if !c.checking { + c.attachCell(&m.memoHeader) + } +} + +// setAfterMarker is set for a result replacing the marker its computation put +// in place when it began. A marker put in place before a cycle began was not +// logged, so discarding the result would restore it; a restored marker that +// stale reports as no longer in progress is cleared instead. Stale is given x +// rather than capturing it so that nothing is allocated unless the set is +// logged. +func setAfterMarker[T comparable, X any](c *Checker, m *memo[T], v T, x X, stale func(*Checker, X, T) bool) { + n := len(c.discardLog) + m.set(c, v) + if len(c.discardLog) > n { + restore := c.discardLog[n].restore + c.discardLog[n].restore = func() { + restore() + if stale(c, x, m.memoValue) { + var zero T + m.memoValue = zero + } + } + } +} + +// setIfChanged is set for a result that every computation needing it sets +// again, such as the symbol a property access resolves to. Setting the value +// it already has comes from the same computation, whose effects are already +// retained, so it is only set when it changes. +func setIfChanged[T comparable](c *Checker, m *memo[T], v T) { + if m.memoValue != v { + m.set(c, v) + } +} + +// setIdentity is set for a result that defines the identity of what it +// caches, such as a declared type, or that is part of an entity being +// created, such as the type of a synthetic property. It is never discarded at +// the end of a cycle: discarding an identity would let a second, distinct +// result exist, and an entity can outlive the cycle in caches that are kept +// while having no way to compute its parts again. +func (m *memo[T]) setIdentity(c *Checker, v T) { + m.memoValue = v + if !c.checking { + c.attachCell(&m.memoHeader) + } +} + +// A memoReported is a memo whose result can have errors to replay; see +// setReported. Reading it accounts for them even when nothing else must be +// accounted for. +type memoReported[T comparable] struct { + memo[T] +} + +func (m *memoReported[T]) cached(c *Checker) T { + if c.observing() || c.memoErrorStates != 0 { + c.observeCell(&m.memoHeader) + } + return m.memoValue +} + +// setReported is setIdentity for a result whose computation collected errors +// reported at the current node, as returned by endCurrentNodeErrors. Every +// node reusing the result reports them again, as it would had it computed the +// result itself. If computing the result elsewhere may not report them (see +// endCurrentNodeErrors), it is instead discarded with other results cached +// for the current node. +func (m *memoReported[T]) setReported(c *Checker, v T, r currentNodeErrors) { + if r.cyclic { + if c.logResults() { + m.logDiscard(c) + } + r.list = nil + } + m.setIdentity(c, v) + if r.list != nil || c.memoErrorStates != 0 && c.peekMemoState(m.key()) != nil { + if r.list != nil { + i := errorFilterIndex(m.key()) + c.errorFilter[i/64] |= 1 << (i % 64) + } + c.memoState(m.key()).setErrors(c, r.list) + } +} + +//go:noinline +func (m *memo[T]) logDiscard(c *Checker) { + old := m.memoValue + c.logMemoDiscard(&m.memoHeader, m.key(), func() { + m.memoValue = old + }) +} + +// inProgress returns the result of a computation in progress, which a +// computation re-entering it may have cached before it finishes. +func (m *memo[T]) inProgress(c *Checker) T { + _, ok := c.resolvingGet(m.key()) + debug.Assert(ok, "the computation of the result is not in progress") + return m.cached(c) +} + +// peek returns the cached result without accounting for effects. It is only +// for a result whose computation is in progress, where reading it does not +// observe it. +func (m *memo[T]) peek() T { + return m.memoValue +} + +// swap replaces the cached result without accounting for effects. It is +// only for speculative computations that restore the previous result after. +func (m *memo[T]) swap(v T) T { + old := m.memoValue + m.memoValue = v + return old +} + +// intern sets the result of a cell whose owner is being created. Nothing can +// observe the owner before its creator returns it, so the result needs no +// dependency of its own. +func (m *memo[T]) intern(v T) { + m.memoValue = v +} + +// begin starts the computation of the result; see beginMemo. +func (m *memo[T]) begin(c *Checker) { + c.beginMemo(m.key()) +} + +// memoCompute returns the result cached in m, computing it in a computation +// of its own if there is none. A result cached while computing it, by a +// computation that re-entered it, is kept. +func (c *Checker) memoCompute[T comparable](m *memo[T], compute func() T) T { + var zero T + if v := m.cached(c); v != zero { + return v + } + m.begin(c) + v := compute() + if cur := m.peek(); cur != zero { + v = cur + } else { + m.set(c, v) + } + c.endMemo() + return v +} + +// internMap is a map of results each constructed from the inputs in its key +// alone, without consulting any cached result, so caching or reusing one has +// no effects to account for. +type internMap[K comparable, V any] struct { + _ memoNoCopy + entries map[K]V +} + +func (m *internMap[K, V]) get(k K) (V, bool) { + v, ok := m.entries[k] + return v, ok +} + +func (m *internMap[K, V]) has(k K) bool { + _, ok := m.entries[k] + return ok +} + +func (m *internMap[K, V]) intern(k K, v V) { + if m.entries == nil { + m.entries = make(map[K]V) + } + m.entries[k] = v +} + +func (m *internMap[K, V]) isEmpty() bool { + return len(m.entries) == 0 +} + +func (m *internMap[K, V]) values() iter.Seq[V] { + return maps.Values(m.entries) +} + +// memoMap is a map of cached results, each accounted for like a memo. The +// entries are only accessible through methods. Memo state is kept per entry +// in a side map allocated on first use by a query. +// +// Most maps never need anything but their entries, and many are embedded in +// types, so everything else lives in a side table allocated on first use. +// +// An entry should be computed between enter and endMemo, so that reusing it +// replays the effects of computing that entry alone. An entry set outside its +// own computation depends on the whole enclosing computation instead. +type memoMap[K comparable, V any] struct { + _ memoNoCopy + memoEntries map[K]V + side *memoMapSide[K] + // The number of writes to memoEntries, with which a caller can tell + // that an entry it read is still current without reading it again. + writes uint32 +} + +type memoMapSide[K comparable] struct { + memoStates map[K]*memoState + // The keys of the computations of entries in progress, which their + // resolutions index, as a resolution cannot hold a key of any type. + resolvingKeys []K + // If set, keyBits returns well-mixed bits of a key, with which stateKeys + // filters the keys that may have a memo state, since few do and looking + // up one that does not costs as much as one that does. + keyBits func(K) uint64 + stateKeys stateKeyFilter + hasErrors bool // Whether an entry ever had reports; see setReported + reentry reentry // What re-entering an entry means; see memoReentry +} + +func (m *memoMap[K, V]) sideTable() *memoMapSide[K] { + if m.side == nil { + m.side = &memoMapSide[K]{} + } + return m.side +} + +// setReentry sets what re-entering an entry of the map means, which is +// reentryCircular by default. +func (m *memoMap[K, V]) setReentry(r reentry) { + m.sideTable().reentry = r +} + +// setKeyBits makes the map filter the keys that may have a memo state with +// keyBits; see memoMapSide. +func (m *memoMap[K, V]) setKeyBits(keyBits func(K) uint64) { + m.sideTable().keyBits = keyBits +} + +// stateOf returns the memo state of the entry for k, or nil. +func (m *memoMap[K, V]) stateOf(k K) *memoState { + s := m.side + if s == nil || s.memoStates == nil { + return nil + } + if s.keyBits != nil && !s.stateKeys.mayContain(s.keyBits(k)) { + return nil + } + return s.memoStates[k] +} + +// cached returns the cached result for k, accounting for the effects of +// computing it. +func (m *memoMap[K, V]) cached(c *Checker, k K) (V, bool) { + if m.side != nil && (c.observing() || m.side.hasErrors) { + m.observe(c, k) + } + v, ok := m.memoEntries[k] + return v, ok +} + +// observe is the out of line part of get, keeping get cheap enough to inline. +// +//go:noinline +func (m *memoMap[K, V]) observe(c *Checker, k K) { + if m.side.memoStates == nil && len(m.side.resolvingKeys) == 0 { + return + } + if c.checking && c.memoPendingCount == 0 && !m.side.hasErrors { + // Only reports are replayed; see observeMemo. + return + } + // A computation in progress may not have a memo state yet; see + // resolutionState. + if state := m.stateOf(k); c.observeState(state) || state == nil && !c.checking { + c.memoCycle(m.resolvingIndex(c, k)) + } +} + +// hasCached reports whether a result is cached for k; see get. +func (m *memoMap[K, V]) hasCached(c *Checker, k K) bool { + _, ok := m.cached(c, k) + return ok +} + +// isEmpty reports whether no result is cached, without observing any. +func (m *memoMap[K, V]) isEmpty() bool { + return len(m.memoEntries) == 0 +} + +// values iterates the cached results without observing them, for +// inspection outside of checking. +func (m *memoMap[K, V]) values() iter.Seq[V] { + return maps.Values(m.memoEntries) +} + +// set caches the result for k; see memo.set. +func (m *memoMap[K, V]) set(c *Checker, k K, v V) { + if c.logResults() { + m.logDiscard(c, k) + } + m.setIdentity(c, k, v) +} + +//go:noinline +func (m *memoMap[K, V]) logDiscard(c *Checker, k K) { + old, ok := m.memoEntries[k] + c.logResultDiscard(c.memoTop != 0 && m.isOwnResolution(c, k), nil, func() { + m.writes++ + if ok { + m.memoEntries[k] = old + } else { + delete(m.memoEntries, k) + } + }) +} + +// setReported is setIdentity for an entry; see memo.setReported. +func (m *memoMap[K, V]) setReported(c *Checker, k K, v V, r currentNodeErrors) { + if r.cyclic { + if c.logResults() { + m.logDiscard(c, k) + } + r.list = nil + } + m.setIdentity(c, k, v) + if r.list != nil || c.memoErrorStates != 0 && m.stateOf(k) != nil { + if r.list != nil { + m.sideTable().hasErrors = true + } + m.state(k).setErrors(c, r.list) + } +} + +// setIdentity is set for a result that defines the identity of what it +// caches; see memo.setIdentity. +func (m *memoMap[K, V]) setIdentity(c *Checker, k K, v V) { + if m.memoEntries == nil { + m.memoEntries = make(map[K]V) + } + m.memoEntries[k] = v + m.writes++ + m.attach(c, k) +} + +// attach is memoAttach for the entry for k. +func (m *memoMap[K, V]) attach(c *Checker, k K) { + if c.memoTop == 0 || c.checking { + return + } + if f := &c.resolutions[c.memoTop-1]; f.source == memoStateSource(m) && m.side.resolvingKeys[f.index] == k { + return + } + c.attachState(m.state(k)) +} + +// intern caches a result constructed from the inputs in k alone, without +// consulting any cached result, so computing it has no effects to account for. +func (m *memoMap[K, V]) intern(k K, v V) { + if m.memoEntries == nil { + m.memoEntries = make(map[K]V) + } + m.memoEntries[k] = v + m.writes++ +} + +// compute computes and caches the result for k in a computation of its own. +func (m *memoMap[K, V]) compute(c *Checker, k K, fn func() V) V { + m.begin(c, k) + v := fn() + m.set(c, k, v) + c.endMemo() + return v +} + +// begin starts the computation of the result for k; see beginMemo. +func (m *memoMap[K, V]) begin(c *Checker, k K) { + side := m.sideTable() + key := m.entryKey(k) + outer := m.resolvingIndexOf(c, k, key) + if outer != 0 { + c.reenter(outer-1, side.reentry) + } + side.resolvingKeys = append(side.resolvingKeys, k) + c.resolving.counts[resolvingHome(key)]++ + c.resolving.count++ + c.appendResolution(key, m, len(side.resolvingKeys)-1, int32(len(c.instantiationStack))) + c.currentResolution().resolving = true + if c.checking && c.memoPendingCount == 0 && c.memoTop|c.currentNodeResolution != 0 && !c.checkingRecords() { + // beginCheckedMemo for the common case, without the calls. The memo + // state of the result is looked up only if needed; see + // resolutionState. + n := len(c.resolutions) - 1 + f := &c.resolutions[n] + f.memo = true + f.prevMemo = int32(c.memoTop) + f.entry = c.currentNode + f.attachStart = int32(len(c.deferredAttach)) + c.memoTop = n + 1 + return + } + // Looked up after marking a cycle, which may give the entry a state. + state := m.stateOf(k) + if c.checking { + if c.memoPendingCount != 0 && state != nil { + c.replayPending(state) + } + c.beginCheckedMemo(state) + return + } + c.beginState(state, outer) +} + +// entryKey returns the key under which Checker.resolving counts the +// computation of the entry for k in progress. Keys of different entries may +// collide, so a computation is found by its entry; see resolvingIndexOf. +func (m *memoMap[K, V]) entryKey(k K) memoKey { + // SAFETY: Only the address of the map is kept, as an identity; it is + // never turned back into a pointer. + h := maphash.Comparable(memoMapSeed, k) ^ spreadBits(uint64(uintptr(unsafe.Pointer(m)))) + return memoKey(h&^0xff | uint64(memoMapEntry)) +} + +var memoMapSeed = maphash.MakeSeed() + +// resolvingIndex returns 1 + the index in resolutions of the computation of +// the entry for k in progress, or 0. +func (m *memoMap[K, V]) resolvingIndex(c *Checker, k K) int { + return m.resolvingIndexOf(c, k, m.entryKey(k)) +} + +func (m *memoMap[K, V]) resolvingIndexOf(c *Checker, k K, key memoKey) int { + if c.resolving.counts[resolvingHome(key)] == 0 { + return 0 + } + for i := c.visibleStart; i < len(c.resolutions); i++ { + if f := &c.resolutions[i]; f.resolving && f.key == key && f.source == memoStateSource(m) && m.side.resolvingKeys[f.index] == k { + return i + 1 + } + } + return 0 +} + +// isOwnResolution reports whether the current resolution computes the entry +// for k. +func (m *memoMap[K, V]) isOwnResolution(c *Checker, k K) bool { + f := c.currentResolution() + return f.source == memoStateSource(m) && m.side.resolvingKeys[f.index] == k +} + +func (m *memoMap[K, V]) stateAt(i int) *memoState { + return m.state(m.side.resolvingKeys[i]) +} + +func (m *memoMap[K, V]) peekStateAt(i int) *memoState { + return m.stateOf(m.side.resolvingKeys[i]) +} + +func (m *memoMap[K, V]) popState(i int) { + clear(m.side.resolvingKeys[i:]) + m.side.resolvingKeys = m.side.resolvingKeys[:i] +} + +func (m *memoMap[K, V]) state(k K) *memoState { + state := m.stateOf(k) + if state == nil { + s := m.sideTable() + if s.memoStates == nil { + s.memoStates = make(map[K]*memoState) + } + state = &memoState{} + s.memoStates[k] = state + if s.keyBits != nil { + s.stateKeys.add(s.keyBits(k), s.memoStates, s.keyBits) + } + } + return state +} + +// memoSet tracks computations that run at most once per key, such as checks +// whose only results are diagnostics. Each run is a computation of its own, so +// skipping a key that already ran accounts for the effects of that run. +type memoSet[K comparable] struct { + m memoMap[K, struct{}] +} + +// hasCached reports whether k hasCached run; see memoMap.get. +func (s *memoSet[K]) hasCached(c *Checker, k K) bool { + return s.m.hasCached(c, k) +} + +// once runs fn unless k has run already. k is marked before fn runs, so fn +// does not run again if it re-enters. +func (s *memoSet[K]) once(c *Checker, k K, fn func()) { + if s.m.hasCached(c, k) { + return + } + s.m.begin(c, k) + s.m.set(c, k, struct{}{}) + fn() + c.endMemo() +} + +// memoActive reports whether reading a cached result must account for its +// effects: false in a check with nothing pending. +func (c *Checker) memoActive() bool { + return !c.checking || c.memoPendingCount|c.memoErrorStates != 0 +} + +// observing reports whether reading a cached result that cannot have errors +// to replay must account for its effects: memoActive, except for results +// with errors, which only memoReported and memoMap cache. It is kept in a +// field for the many reads that check it. +func (c *Checker) observing() bool { + return c.observingMemos +} + +// syncObserving updates observingMemos after a change to what it depends +// on: the checking flag or the counts it reads. The counts are shared with other checkers using the same +// store, but those only run while this one is not checking, and it syncs on +// starting to check. +func (c *Checker) syncObserving() { + c.observingMemos = !c.checking || c.memoPendingCount != 0 +} + +// readsWithoutMemo reports whether a memoized computation identified by key, +// whose result is cached, can read it without beginning the memo: when no +// memo is active, the memo records and replays nothing, and the computation +// only reads, unless it re-enters itself in progress, with the result +// published before it is complete. +func (c *Checker) readsWithoutMemo(key memoKey) bool { + if c.observing() { + return false + } + _, resolving := c.resolvingGet(key) + return !resolving +} + +// beginMemo is called on entry to a memoized function whose result for this +// input is cached in the memo state identified by key. It accounts for +// effects recorded by a previous computation of that result, and starts a +// resolution for this computation, which in a query records its effects. It +// must be matched by endMemo. +func (c *Checker) beginMemo(key memoKey) { + resolving := c.beginResolving(key) + c.appendResolution(key, nil, 0, int32(len(c.instantiationStack))) + n := len(c.resolutions) - 1 + f := &c.resolutions[n] + f.resolving = resolving + if c.checking && c.memoPendingCount == 0 && c.memoTop|c.currentNodeResolution != 0 && !c.checkingRecords() { + // beginCheckedMemo for the common case, without the calls. The memo + // state of the result is looked up only if needed; see + // resolutionState. + f.memo = true + f.prevMemo = int32(c.memoTop) + f.entry = c.currentNode + f.attachStart = int32(len(c.deferredAttach)) + c.memoTop = n + 1 + return + } + state := c.peekMemoState(key) + if c.checking { + if c.memoPendingCount != 0 { + c.replayPending(state) + } + c.beginCheckedMemo(state) + return + } + outer := c.resolvingIndex(key) + if outer == len(c.resolutions) { + outer = 0 + } + c.beginState(state, outer) +} + +// beginState is beginMemo for the memo state of a result, in a query. outer +// is 1 + the index in resolutions of the computation of the same result in +// progress, if this one re-enters it, or 0. +func (c *Checker) beginState(state *memoState, outer int) { + if state != nil && state.pending != nil { + c.observePending(state.pending) + } + c.startEffects(state) + // Re-entering a computation in progress: the inner result is derived + // from whatever in-progress marker the outer computation left behind. + c.memoCycle(outer) +} + +// startEffects starts recording the effects of the current resolution, which +// computes the result in state. +func (c *Checker) startEffects(state *memoState) { + n := len(c.resolutions) - 1 + f := &c.resolutions[n] + f.memo = true + f.prevMemo = int32(c.memoTop) + f.result = state + f.entry = c.currentNode + f.attachStart = int32(len(c.deferredAttach)) + if c.memoTop == 0 && c.currentNodeResolution == 0 { + // A query made outside of checking: errors located at the current + // node are located wherever checking reuses the result, so results + // they depend on are discarded once the query finishes (see + // reportAtCurrentNode), and every reuse computes them again. The + // node's resolution is entered above the computation's resolution. + debug.Assert(c.queryRoot == 0, "nested query") + c.queryRoot = n + 1 + c.querySave = c.enterCurrentNode(c.currentNode) + } + c.memoTop = n + 1 +} + +// stopEffects stops recording the effects of the current resolution, +// returning it if it recorded them. +func (c *Checker) stopEffects() *resolution { + n := len(c.resolutions) - 1 + if c.queryRoot == n && c.currentNodeResolution == n+1 { + n-- + c.exitCurrentNode(c.querySave) + c.queryRoot = 0 + } + f := &c.resolutions[n] + if !f.memo { + return nil + } + c.memoTop = int(f.prevMemo) + return f +} + +func (c *Checker) memoState(key memoKey) *memoState { + state := c.memoStates[key] + if state == nil { + if c.memoStates == nil { + c.memoStates = make(map[memoKey]*memoState) + } + state = &memoState{} + c.memoStates[key] = state + c.stateFilter.add(memoKeyBits(key), c.memoStates, memoKeyBits) + } + return state +} + +// stateKeyFilter is a filter of the keys of a map of memo states, given by +// well-mixed bits of each key, sized to the number of states so that it stays +// in cache: few results have a memo state. +type stateKeyFilter struct { + words []uint64 + shift uint8 // 64 - log2 of the number of bits +} + +// Bits per state below which the filter grows, keeping false positives +// to a few percent. +const stateFilterBitsPerState = 16 + +// spreadBits spreads the bits of x over the high bits of the result, from +// which hash tables and filters take their indexes. +func spreadBits(x uint64) uint64 { + return x * 0x9E3779B97F4A7C15 +} + +func memoKeyBits(key memoKey) uint64 { + return spreadBits(uint64(key)) +} + +func (f *stateKeyFilter) mayContain(h uint64) bool { + if f.words == nil { + return false + } + i := h >> f.shift + return f.words[i/64]&(1<<(i%64)) != 0 +} + +// add adds the key with bits h, which states has just been given a state +// for. +func (f *stateKeyFilter) add[K comparable](h uint64, states map[K]*memoState, keyBits func(K) uint64) { + if n := 64 * len(f.words); n < stateFilterBitsPerState*len(states) { + n = max(2*n, 1<<15) + f.words = make([]uint64, n/64) + f.shift = uint8(65 - bits.Len(uint(n))) + for k := range states { + f.set(keyBits(k)) + } + return + } + f.set(h) +} + +func (f *stateKeyFilter) set(h uint64) { + i := h >> f.shift + f.words[i/64] |= 1 << (i % 64) +} + +const errorFilterBits = 12 + +type errorKeyFilter [1 << errorFilterBits / 64]uint64 + +func errorFilterIndex(key memoKey) uint64 { + return spreadBits(uint64(key)) >> (64 - errorFilterBits) +} + +// peekMemoState returns the memo state of the result identified by key, or +// nil if it has none, consulting a filter first since most results have none. +func (c *Checker) peekMemoState(key memoKey) *memoState { + if !c.stateFilter.mayContain(memoKeyBits(key)) { + return nil + } + return c.memoStates[key] +} + +// memoAttach makes the result identified by key depend on the innermost +// computation in progress, unless that computation is the result's own. +func (c *Checker) memoAttach(key memoKey) { + if c.memoTop == 0 || c.checking { + return + } + if f := &c.resolutions[c.memoTop-1]; f.source == nil && f.key == key { + return + } + if c.resolutions[c.memoTop-1].effects == nil && !c.logEffects() { + // See attachState; the memo state is created only if needed. + c.deferredAttach = append(c.deferredAttach, deferredAttachment{key: key}) + return + } + c.attachState(c.memoState(key)) +} + +// A deferredAttachment is a result cached by a computation that had no +// effects yet; see attachState. A result of a memo cell is identified by its +// key, so that its memo state is created only if needed. +type deferredAttachment struct { + state *memoState + key memoKey +} + +// attachState is memoAttach for the memo state of a result. +func (c *Checker) attachState(state *memoState) { + n := c.memoTop - 1 + if n < 0 { + return + } + if c.peekResolutionState(&c.resolutions[n]) == state { + // Writers skip their own computation before creating its state, so + // a state created later is never the computation's own. + return + } + if c.resolutions[n].effects == nil && !c.logEffects() { + // Until the computation has effects, the result depends on nothing, + // and most computations never have any; memoEffectsAt attaches the + // result if it gets some. + c.deferredAttach = append(c.deferredAttach, deferredAttachment{state: state}) + return + } + c.linkState(state, c.memoEffectsAt(n), c.logResults()) +} + +// linkState makes the result in state depend on the effects f of the +// computation that cached it, logging the change in the discard log if log. +func (c *Checker) linkState(state *memoState, f *memoEffects, log bool) { + if log { + c.logPendingDiscard(state) + } + switch { + case state.pending == nil: + // Replaying f is replaying a set of deps holding only f. + state.pending = f + c.memoPendingCount++ + c.syncObserving() + if c.recordingFromCheck { + c.flushBuf = append(c.flushBuf, state) + } + case state.pending == f: + // Already depends on f. + case state.pending.entered: + // The effects of a computation are shared with whatever else + // depends on it, so they cannot gain a dependency of the result. + deps := &memoEffects{} + deps.addDep(state.pending) + deps.addDep(f) + state.pending = deps + default: + state.pending.addDep(f) + } +} + +// observeCell and attachCell are observeMemo and memoAttach for a memo at +// address p. They are kept out of line so that memo reads and writes are +// cheap enough to inline. +// +//go:noinline +func (c *Checker) observeCell(h *memoHeader) { + c.observeMemo(h.key()) +} + +//go:noinline +func (c *Checker) attachCell(h *memoHeader) { + c.memoAttach(h.key()) +} + +// observeMemo accounts for reading a memoized result without computing it. +func (c *Checker) observeMemo(key memoKey) { + if !c.memoActive() { + return + } + if c.checking && c.memoPendingCount == 0 { + // Only reports are replayed, which few results have, so a filter + // small enough to stay in cache rules out most. + if i := errorFilterIndex(key); c.errorFilter[i/64]&(1<<(i%64)) == 0 { + return + } + } + // A computation in progress may not have a memo state yet; see + // resolutionState. + if state := c.peekMemoState(key); c.observeState(state) || state == nil && !c.checking && c.resolving.count != 0 { + c.memoCycle(c.resolvingIndex(key)) + } +} + +// observeState is observeMemo for the memo state of a result, if it has one. +// It reports whether the result is read in a query, in which case reading a +// computation in progress is left to the caller; see memoCycle. +func (c *Checker) observeState(state *memoState) bool { + if state == nil { + return false + } + if state.errors != nil { + c.replayCurrentNodeErrors(*state.errors) + } + if c.checking { + c.replayPending(state) + return false + } + if state.pending != nil { + c.observePending(state.pending) + } + return true +} + +// observePending adds the effects of a reused result to the enclosing +// computation. Those of a computation started at no node are located where +// it is reused, so if that is not where the enclosing computation started, +// the node is kept with them; replay would otherwise locate them wherever the +// enclosing computation is reused. +func (c *Checker) observePending(pending *memoEffects) { + parent := c.currentMemoEffects() + if parent == nil { + return + } + if c.currentNode != nil && c.currentNode != parent.entry && (!pending.entered || pending.entry == nil) { + pending = &memoEffects{deps: []*memoEffects{pending}, entry: c.currentNode, entered: true} + } + parent.addDep(pending) +} + +// A currentNodeError is an error reported at the current node; see +// reportAtCurrentNode. Replaying it reports the same *currentNodeError, so +// that reports collected more than once can be told apart from distinct ones. +type currentNodeError struct { + report func(c *Checker, node *ast.Node) +} + +type currentNodeErrorsMark struct { + errors int + cyclic bool +} + +// currentNodeErrors are the errors a computation reported at the current +// node. +type currentNodeErrors struct { + list []*currentNodeError + cyclic bool // Whether the computation observed a cycle, so computing it elsewhere may not report them +} + +// startCurrentNodeErrors starts collecting the errors a computation reports +// at the current node, to be passed to endCurrentNodeErrors when it finishes. +func (c *Checker) startCurrentNodeErrors() currentNodeErrorsMark { + c.currentNodeErrorCollectors++ + mark := currentNodeErrorsMark{len(c.currentNodeErrors), c.currentNodeErrorsCyclic} + c.currentNodeErrorsCyclic = false + return mark +} + +// endCurrentNodeErrors returns the errors reported at the current node since +// mark. +func (c *Checker) endCurrentNodeErrors(mark currentNodeErrorsMark) currentNodeErrors { + var r currentNodeErrors + for _, report := range c.currentNodeErrors[mark.errors:] { + // Reusing a result more than once reports its errors each time. + if !slices.Contains(r.list, report) { + r.list = append(r.list, report) + } + } + // Which errors a cycle reports depends on where it is entered, so they + // are only reported where the result is computed. + r.cyclic = r.list != nil && c.currentNodeErrorsCyclic + c.currentNodeErrorsCyclic = c.currentNodeErrorsCyclic || mark.cyclic + c.currentNodeErrorCollectors-- + if c.currentNodeErrorCollectors == 0 { + clear(c.currentNodeErrors) + c.currentNodeErrors = c.currentNodeErrors[:0] + c.currentNodeErrorsCyclic = false + } + return r +} + +func (s *memoState) setErrors(c *Checker, reports []*currentNodeError) { + switch { + case s.errors == nil && reports != nil: + c.memoErrorStates++ + c.syncObserving() + case s.errors != nil && reports == nil: + c.memoErrorStates-- + c.syncObserving() + } + if reports == nil { + s.errors = nil + } else { + s.errors = &reports + } +} + +// replayCurrentNodeErrors reports at the current node the errors that +// computing a reused result reported at the node it was computed for. +// +//go:noinline +func (c *Checker) replayCurrentNodeErrors(reports []*currentNodeError) { + for _, r := range reports { + c.reportNode(r) + } +} + +func (c *Checker) replayPending(state *memoState) { + if state != nil && state.pending != nil { + if c.holdingEffects() { + c.logPendingDiscard(state) + } + f := state.pending + state.pending = nil + c.memoPendingCount-- + c.syncObserving() + c.replayMemo(f) + } +} + +// endMemo finishes a computation started by beginMemo, retaining its effects +// for replay by later reuse of the result. The effects also become part of +// the enclosing computation, since it observed the result. +func (c *Checker) endMemo() { + n := len(c.resolutions) - 1 + if f := &c.resolutions[n]; f.memo && f.effects == nil && !f.fromCheck { + // stopEffects and endResolution for the common case, without the + // calls. + c.memoTop = int(f.prevMemo) + if f.resolving { + c.resolving.counts[resolvingHome(f.key)]-- + c.resolving.count-- + } + if int(f.attachStart) != len(c.deferredAttach) { + clear(c.deferredAttach[f.attachStart:]) + c.deferredAttach = c.deferredAttach[:f.attachStart] + } + if f.source != nil { + f.source.popState(int(f.index)) + } + c.dropResolution(n) + return + } + if f := c.stopEffects(); f != nil && f.effects != nil { + c.retainEffects(c.resolutionState(f), f.effects) + } + c.endResolution() +} + +// markReadIncomplete marks the computations in progress above the one at +// index i, which is re-entered, as reading its incomplete result: either the +// in-progress marker of a circular computation or the part of a partial +// result published so far. What they compute from here on may be derived +// from it; see logResultDiscard. +func (c *Checker) markReadIncomplete(i int) { + // Every resolution from i+1 up is marked by the floor, until the stack + // shrinks below it, so that marking does not walk the stack. + if i+1 < len(c.resolutions) && (c.readIncompleteFloor == 0 || int32(i+1) < c.readIncompleteFloor) { + c.readIncompleteFloor = int32(i + 1) + } +} + +// endMemoUncached is endMemo for a computation that did not cache its result. +// Nothing can reuse the result, so its effects belong only to the enclosing +// computation, and retaining them for the result would grow them each time it +// is computed again. +func (c *Checker) endMemoUncached() { + defer c.endResolution() + res := c.stopEffects() + c.forgetResult() + if res == nil || res.effects == nil { + return + } + f := res.effects + if parent := c.currentMemoEffects(); parent != nil { + if len(f.effects) == 0 && (f.rare == nil || len(f.rare.marks) == 0) && f.entry == parent.entry { + // Without effects of its own, and located like the enclosing + // computation, the computation adds nothing but what it observed. + for _, d := range f.deps { + parent.addDep(d) + } + } else { + parent.addDep(f) + } + } else if c.recordingFromCheck { + c.retainEffects(c.resolutionState(res), f) + } +} + +// resolutionState returns the memo state of the result a memo resolution +// computes, creating it on first use, since most computations have no +// effects to retain. +func (c *Checker) resolutionState(f *resolution) *memoState { + if f.result == nil { + switch { + case f.source != nil: + f.result = f.source.stateAt(int(f.index)) + case f.key != 0: + f.result = c.memoState(f.key) + default: + // The computation caches no result; see forgetResult. + f.result = &memoState{} + } + } + return f.result +} + +// peekResolutionState is resolutionState without creating the memo state, +// returning nil if the result has none yet. +func (c *Checker) peekResolutionState(f *resolution) *memoState { + if f.result == nil { + switch { + case f.source != nil: + f.result = f.source.peekStateAt(int(f.index)) + case f.key != 0: + f.result = c.peekMemoState(f.key) + } + } + return f.result +} + +// retainEffects retains the effects of a computation that just finished for +// replay by later reuse of its result, and adds them to the enclosing +// computation. +func (c *Checker) retainEffects(state *memoState, f *memoEffects) { + if state.pending != nil && len(f.effects) == 0 && state.pending.covers(f.deps) { + // Computing the result again, typically to return it from a cache + // that the computation reads, observed only what computing it + // before did. Retaining that again would grow the effects of the + // result each time. + if parent := c.currentMemoEffects(); parent != nil { + parent.addDep(state.pending) + } + return + } + if state.pending == nil && len(f.effects) == 0 && f.rare == nil && len(f.deps) == 1 && f.deps[0].entered && f.deps[0].entry == f.entry { + // The computation only observed one result computed at the same + // node, whose effects replay the same way without it. + f = f.deps[0] + } + if c.logEffects() { + c.logPendingDiscard(state) + } + if state.pending != nil { + f.addDep(state.pending) + } else { + c.memoPendingCount++ + c.syncObserving() + if c.recordingFromCheck { + c.flushBuf = append(c.flushBuf, state) + } + } + state.pending = f + if parent := c.currentMemoEffects(); parent != nil { + parent.addDep(f) + } +} + +func (c *Checker) replayMemo(f *memoEffects) { + c.replayEffects(f, nil, false) +} + +// replayEffects replays the effects of f and its dependencies. Effects +// located at the current node that a computation started with (see +// reportAtCurrentNode) are located at the node the reuse happens at instead, +// as they would be had the computation happened there, unless the computation +// started at a different node than the computation replaying it, which then +// fixes its location. Replaying f empties it, so that revisiting it through +// other dependencies replays nothing. +func (c *Checker) replayEffects(f *memoEffects, outerEntry *ast.Node, outerEntered bool) { + effects, deps := f.effects, f.deps + var marks []func(c *Checker) + if f.rare != nil { + marks = f.rare.marks + } + f.effects, f.deps, f.rare = nil, nil, nil + saveCurrentNode := c.currentNode + if f.entered { + // A computation that started at no node can be located anywhere, + // like one started at the node it is reused at. + if outerEntered && f.entry != outerEntry && f.entry != nil { + c.currentNode = f.entry + } + outerEntry, outerEntered = f.entry, true + } + if !f.dropped { + for _, e := range effects { + e(c) + } + } + for _, m := range marks { + m(c) + } + for _, d := range deps { + c.replayEffects(d, outerEntry, outerEntered) + } + c.currentNode = saveCurrentNode +} + +// atMemoStartNode reports whether the current node is the one the innermost +// computation in progress started with. +func (c *Checker) atMemoStartNode() bool { + n := c.memoTop - 1 + return n >= 0 && c.resolutions[n].entry == c.currentNode +} + +func (c *Checker) currentMemoEffects() *memoEffects { + if c.memoTop == 0 { + return nil + } + return c.memoEffectsAt(c.memoTop - 1) +} + +// recordEffect records a side effect produced by a query against the +// innermost memoized computation, if any. Callers must only call this when +// !c.checking, and must not apply the effect themselves. +func (c *Checker) recordEffect(effect func(c *Checker)) { + if f := c.currentMemoEffects(); f != nil { + f.effects = append(f.effects, effect) + } +} + +// recordMark records mark, which writes a mark (see writesMarks), as an +// effect of the computation in progress that dropping its effects keeps. +func (c *Checker) recordMark(mark func(c *Checker)) { + if f := c.currentMemoEffects(); f != nil { + rare := f.rareFields() + rare.marks = append(rare.marks, mark) + } +} + +// beginCheckedMemo is beginMemo for a computation started in a check. Its +// effects apply as they happen, and reading cached results accounts for +// nothing, as every effect only adds to what the store has collected, which +// is the same whichever check applies it first. Effects of results that a +// cycle or a discard mark may discard are the exception (see recordFromCheck), +// so a computation starting while one is in progress records them. +func (c *Checker) beginCheckedMemo(state *memoState) { + c.startEffects(state) + if c.checkingRecords() { + c.recordFromCheck() + } +} + +// checkingRecords reports whether a check records the effects of what it +// computes rather than applying them, because a cycle or a discard mark in +// progress may discard it. A variance measurement that may be discarded +// does not make it record; see holdEffect. +func (c *Checker) checkingRecords() bool { + return c.circularityStart != 0 || c.effectsMarkDepth != 0 +} + +// holdingEffects reports whether a check holds the effects it applies; see +// holdEffect. +func (c *Checker) holdingEffects() bool { + return c.varianceCycleRoot != 0 +} + +// holdEffect holds an effect a check applies while a variance measurement in +// progress may still be discarded (see getRecursiveVariances), to apply it +// once nothing can discard it, unless what produced it is discarded first. +// Few measurements are discarded, so a check holds their effects rather +// than recording them with every result, which costs far more. +func (c *Checker) holdEffect(effect func(c *Checker)) { + n := len(c.heldEffects) + c.heldEffects = append(c.heldEffects, effect) + c.logRestore(func() { + clear(c.heldEffects[n:]) + c.heldEffects = c.heldEffects[:n] + }) +} + +// applyHeldEffects applies the effects held by holdEffect above the floor +// (see trimDiscardLog), as the check that produced them would have. +func (c *Checker) applyHeldEffects() { + effects := slices.Clone(c.heldEffects[c.heldEffectsFloor:]) + clear(c.heldEffects[c.heldEffectsFloor:]) + c.heldEffects = c.heldEffects[:c.heldEffectsFloor] + saveChecking := c.checking + c.checking = true + c.syncObserving() + for _, e := range effects { + e(c) + } + c.checking = saveChecking + c.syncObserving() +} + +// recordFromCheck makes the outermost computation in progress in a check, if +// any, a query from here on, because a cycle or a discard mark begins, after which +// results and their effects may be discarded. Effects are then recorded with +// the results computed and with every result observing them, and are replayed +// when the outermost computation finishes (see endQueryFromCheck), so that +// those of discarded results apply only if a result that is kept observed +// them. The computations in progress applied their earlier effects already, +// which is right since they are kept: a cycle discards only what is computed +// after it is found, and a mark only what is computed after it is taken. +func (c *Checker) recordFromCheck() { + if !c.checking || c.memoTop == 0 { + return + } + debug.Assert(!c.recordingFromCheck, "recording from a check already recording") + i := c.memoTop - 1 + for c.resolutions[i].prevMemo != 0 { + i = int(c.resolutions[i].prevMemo) - 1 + } + c.resolutions[i].fromCheck = true + c.checking = false + c.syncObserving() + c.flushBuf = c.flushBuf[:0] + c.recordingFromCheck = true +} + +// endQueryFromCheck ends the query begun by recordFromCheck, replaying +// the effects of everything it computed in the check. +func (c *Checker) endQueryFromCheck() { + if !c.recordingFromCheck { + // The query already ended; see resumeChecking. + return + } + states := c.flushBuf + c.recordingFromCheck = false + c.checking = true + c.syncObserving() + defer clear(states) + c.replayFlushed(states) +} + +func (c *Checker) replayFlushed(states []*memoState) { + for _, state := range states { + if state.pending != nil { + if c.holdingEffects() { + c.logPendingDiscard(state) + } + f := state.pending + state.pending = nil + c.memoPendingCount-- + c.syncObserving() + c.replayEffects(f, c.currentNode, true) + } + } +} + +// resumeChecking ends the query begun by recordFromCheck as soon as nothing +// computed since can be discarded: no cycle is in progress and no effects +// mark is held. Recording until the outermost computation finishes would be +// equivalent, but makes every read until then account for effects. What the +// query recorded applies now, as it would have in the check, including what +// the computations in progress recorded, which continue as in a check. +func (c *Checker) resumeChecking() { + if c.checking || !c.recordingFromCheck || c.checkingRecords() || len(c.innerCycles) != 0 || len(c.discardLog) != 0 && !c.holdingEffects() { + return + } + chain := c.resumeBuf[:0] + for i := c.memoTop - 1; i >= 0; i = int(c.resolutions[i].prevMemo) - 1 { + chain = append(chain, i) + } + saveCurrentNode := c.currentNode + if len(chain) != 0 { + root := &c.resolutions[chain[len(chain)-1]] + root.fromCheck = false + if root.entry != nil { + // The effects apply as they would when the outermost computation + // finishes, back at the node it started at. + c.currentNode = root.entry + } + } + states := c.flushBuf + c.recordingFromCheck = false + c.checking = true + c.syncObserving() + c.replayFlushed(states) + clear(states) + loc := c.currentNode + for _, i := range slices.Backward(chain) { + r := &c.resolutions[i] + if f := r.effects; f != nil { + r.effects = nil + c.currentNode = loc + c.replayEffects(f, loc, true) + } + if r.entry != nil { + loc = r.entry + } + } + c.currentNode = saveCurrentNode + clear(chain) + c.resumeBuf = chain[:0] +} + +// withChecking runs fn in a check. +func (c *Checker) withChecking(fn func()) { + // Checking starts only from top-level requests, so any resolution left at + // this point was never exited and would absorb unrelated effects. + debug.Assert(c.memoTop == 0, "memo resolution leaked") + saveChecking := c.checking + c.checking = true + c.syncObserving() + fn() + c.checking = saveChecking + c.syncObserving() +} + +// memoCycle is called when a computation observes another computation that is +// still in progress, whose resolution is at index depth-1. Every computation +// started since then produced its result from the incomplete state of that +// computation, so reusing any of them must also replay the effects of the +// whole cycle (for example, its circularity error). +func (c *Checker) memoCycle(depth int) { + if depth == 0 || !c.resolutions[depth-1].memo { + // The outer computation does not record effects. + return + } + var outer *memoEffects + // A computation that depends on a cycle head depends on every computation + // in progress above the head, as their effects become part of the head's. + // So walk down from the top, stopping at a computation an earlier reentry + // already made depend on outer or a head below it: the computations below + // it were in progress then too, so they depend on that head as well. + // Without this, every reentry of a cycle would walk, and grow, the whole + // stack. + head := depth - 1 + for i := len(c.resolutions) - 1; i >= depth; i-- { + if !c.resolutions[i].memo { + continue + } + if outer == nil { + // Typically, the computation reads its own result, and no + // computation in between depends on it. + outer = c.memoEffectsAt(depth - 1) + } + f := c.memoEffectsAt(i) + if f == outer || outer.parent == f { + continue + } + if h := f.cycleHead(); h >= 0 && h <= head { + break + } + if i < c.effectsMarkDepth-1 { + // The resolution is in progress below the mark, so discarding to + // the mark must also discard this dependency. + c.logDepsDiscard(f) + } + rare := f.rareFields() + rare.cycles = append(rare.cycles, memoCycleDep{dep: int32(len(f.deps)), head: int32(head)}) + f.deps = append(f.deps, outer) + outer.parent = f + } +} + +// A memoCycleDep is a dependency memoCycle added on a cycle head. +type memoCycleDep struct { + dep int32 // Index in deps + head int32 // Index of the head's resolution +} + +// cycleHead returns the index of the resolution of the lowest cycle head that +// memoCycle made f depend on, or -1. +func (f *memoEffects) cycleHead() int { + if f.rare == nil || len(f.rare.cycles) == 0 { + return -1 + } + return int(f.rare.cycles[len(f.rare.cycles)-1].head) +} + +// logDepsDiscard logs the dependencies of a computation in progress below the +// innermost effects mark, which are about to grow, so discardSince can +// restore them. +// +//go:noinline +func (c *Checker) logDepsDiscard(f *memoEffects) { + n := len(f.deps) + c.discardLog = append(c.discardLog, discardEntry{effects: true, restore: func() { + if len(f.deps) > n { + f.truncateDeps(n) + } + }}) +} + +func (c *Checker) memoEffectsAt(i int) *memoEffects { + f := c.resolutions[i].effects + if f == nil { + f = &memoEffects{entry: c.resolutions[i].entry, entered: true} + c.resolutions[i].effects = f + c.attachDeferred(i, f) + } + return f +} + +// attachDeferred attaches the results the memo resolution at index i cached +// before it had effects f; see attachState. A result cached before an effects +// mark or a cycle is attached as if it had been attached then, so the discard +// log does not log it. +// +//go:noinline +func (c *Checker) attachDeferred(i int, f *memoEffects) { + start := int(c.resolutions[i].attachStart) + end := len(c.deferredAttach) + for j := i + 1; j < len(c.resolutions); j++ { + if c.resolutions[j].memo { + end = int(c.resolutions[j].attachStart) + break + } + } + if start == end { + return + } + for k := start; k < end; k++ { + d := c.deferredAttach[k] + c.deferredAttach[k] = deferredAttachment{} + switch { + case d.state != nil: + c.linkState(d.state, f, false) + case d.key != 0: + c.linkState(c.memoState(d.key), f, false) + } + } +} + +// Cycles +// +// A cached result must be the result of computing it from scratch, so that +// it does not depend on which computation happened to request it first. A +// computation that observes another computation still in progress (a +// circularity) sees a provisional state, so results cached from the moment +// the cycle is detected until the outermost computation of the cycle (its +// head) finishes may differ from computing them from scratch. Those results +// are discarded when the head finishes, and are recomputed when next +// requested. The computations that were in progress when the cycle was +// detected (its participants) are kept: each of them reaches the cycle when +// computed from scratch too, so each result is the fallback for a circularity +// whichever participant is computed first. +// +// Type comparisons are the exception: a comparison that reaches itself +// assumes it holds rather than being a circularity, since relations are +// coinductive. The Relater tracks those assumptions itself (see +// recursiveTypeRelatedTo), and caches only results that hold whatever they +// assumed. Each comparison is still a resolution, so circularities through +// other computations it needs are handled as above, discarding the relation +// results cached during them. A comparison that needs another relater, as in +// variance measurement, does not see the assumptions of the outer one, so it +// compares from scratch, as it would if run first. + +// Discard log +// +// Some computations run provisionally, and may have to be discarded as if +// they had never run: those in a cycle (see above), and those a computation +// that retries from a mark runs before retrying (see markDiscard). While any +// of them is in progress, what they cache is logged in the discard log, from +// which each discards to the position where it started. The discard log is +// cleared once nothing in progress can discard. + +type discardEntry struct { + memo *memoHeader // The memo restored, or nil + drop *memoEffects // Effects to drop when discarded; see logResultDiscard + restore func() + effects bool // Restores the effects of a result rather than the result +} + +// logResultDiscard appends a result restore entry to the discard log. If own, +// the innermost computation in progress computes the result, and if it read +// the incomplete result of a computation in progress (see markReadIncomplete) +// without reporting an error located at the current node, discarding the +// result also drops the computation's own effects: they may be derived from +// the incomplete result, so they would report errors that computing from +// complete results does not, while the results it reused are still replayed. +func (c *Checker) logResultDiscard(own bool, memo *memoHeader, restore func()) { + var drop *memoEffects + if own { + if f := &c.resolutions[c.memoTop-1]; c.readIncompleteAt(c.memoTop-1) && !f.reportsAtCurrentNode { + drop = f.effects + } + } + c.discardLog = append(c.discardLog, discardEntry{memo: memo, drop: drop, restore: restore}) +} + +func (c *Checker) logMemoDiscard(memo *memoHeader, key memoKey, restore func()) { + c.logResultDiscard(c.memoTop != 0 && c.resolutions[c.memoTop-1].source == nil && c.resolutions[c.memoTop-1].key == key, memo, restore) +} + +// logResults reports whether caching a result must be logged in the discard +// log. +func (c *Checker) logResults() bool { + return c.circularityStart != 0 || c.varianceCycleRoot != 0 || c.instantiationAborted +} + +// logEffects reports whether changing the effects of a result must be logged +// in the discard log. +func (c *Checker) logEffects() bool { + return c.circularityStart != 0 || c.effectsMarkDepth != 0 || c.varianceCycleRoot != 0 || c.instantiationAborted +} + +// discardLogSince restores everything logged in the discard log since +// position start. +func (c *Checker) discardLogSince(start int) { + start = min(start, len(c.discardLog)) + for i := range c.innerCycles { + c.innerCycles[i].mark = min(c.innerCycles[i].mark, start) + } + for i := range c.varianceStack { + c.varianceStack[i].discardLog = min(c.varianceStack[i].discardLog, start) + } + for i := len(c.discardLog) - 1; i >= start; i-- { + if d := c.discardLog[i].drop; d != nil { + d.dropped = true + } + c.discardLog[i].restore() + } + clear(c.discardLog[start:]) + c.discardLog = c.discardLog[:start] +} + +// trimDiscardLog clears the discard log if nothing in progress can discard. +// While a variance measurement is measured again from the canonical entry of +// its circularity, the measurements in progress are hidden, but may still be +// discarded once it finishes, so the part of the log logged for them before +// it began is kept, with the effects a check held for them; see +// getVariancesWorker. +func (c *Checker) trimDiscardLog() { + if !c.logEffects() && len(c.discardLog) > c.discardLogFloor { + for i := range c.varianceStack { + c.varianceStack[i].discardLog = min(c.varianceStack[i].discardLog, c.discardLogFloor) + } + clear(c.discardLog[c.discardLogFloor:]) + c.discardLog = c.discardLog[:c.discardLogFloor] + if len(c.heldEffects) > c.heldEffectsFloor { + c.applyHeldEffects() + } + } +} + +// A flag memo is a cached result held outside a memo, so that it costs no +// space of its own: bits of a flags word shared with other results, or a +// field of storage allocated only when needed. It is accounted for like a +// memo under a key naming its entity and field. Readers finding it cached +// call observeFlagMemo; it is computed between beginMemo and endMemo for the +// key, and cached with setFlagMemoBits or setFlagMemoValue, or with +// setFlagMemo after logging how to discard it with logMemoDiscard. + +// observeFlagMemo accounts for reading the flag memo identified by key. +func (c *Checker) observeFlagMemo(key memoKey) { + if c.observing() { + c.observeMemo(key) + } +} + +// setFlagMemo accounts for caching the result of the flag memo identified by +// key, as memo.set does. +func (c *Checker) setFlagMemo(key memoKey) { + if !c.checking { + c.memoAttach(key) + } +} + +// logRestore logs how to discard part of a result, or state derived from +// results, in the discard log; the caller checks logResults so that the +// closure is only allocated when needed. +// +//go:noinline +func (c *Checker) logRestore(restore func()) { + c.discardLog = append(c.discardLog, discardEntry{restore: restore}) +} + +// objectFlagsKnown reports whether the flag memo of t whose result is cached +// once computed is set can be read without objectFlagsCell, which callers +// check first since objectFlagsCell is too large to inline. +func (c *Checker) objectFlagsKnown(t *Type, computed ObjectFlags) bool { + return t.objectFlags&computed != 0 && !c.observingMemos +} + +// objectFlagsCell returns the flags under value of t, a flag memo whose +// result is cached once the computed flag is set, computing them in a +// computation of their own if needed. With inProgress, the computed flag is +// set while computing, so that a computation re-entering it finds no flags. +func (c *Checker) objectFlagsCell(t *Type, field memoField, computed ObjectFlags, value ObjectFlags, inProgress bool, compute func() ObjectFlags) ObjectFlags { + key := memoKeyOf(t, field) + if t.objectFlags&computed != 0 { + c.observeMemo(key) + return t.objectFlags & value + } + c.beginMemo(key) + if inProgress { + setFlagMemoBits(c, key, &t.objectFlags, computed|value, computed) + } + result := compute() & value + if inProgress || t.objectFlags&computed == 0 { + setFlagMemoBits(c, key, &t.objectFlags, computed|value, computed|result) + } else { + result = t.objectFlags & value + } + c.endMemo() + return result +} + +// setFlagMemoBits caches the bits of *p under mask as the result of the flag +// memo identified by key. +func setFlagMemoBits[T ~uint32](c *Checker, key memoKey, p *T, mask T, bits T) { + if c.logResults() { + old := *p & mask + c.logMemoDiscard(nil, key, func() { *p = *p&^mask | old }) + } + *p = *p&^mask | bits&mask + c.setFlagMemo(key) +} + +// setFlagMemoValue caches v in *p as the result of the flag memo identified +// by key. +func (c *Checker) setFlagMemoValue[T any](key memoKey, p *T, v T) { + if c.logResults() { + old := *p + c.logMemoDiscard(nil, key, func() { *p = old }) + } + *p = v + c.setFlagMemo(key) +} + +// endCircularity discards the results cached since the outermost cycle in +// progress was detected, except those of its participants. +func (c *Checker) endCircularity() { + mark := min(c.circularityMark, len(c.discardLog)) + c.circularityStart = 0 + c.circularityMark = 0 + c.innerCycles = c.innerCycles[:0] + c.discardCycle(mark, false) + c.cycleParticipants = nil + c.trimDiscardLog() + c.resumeChecking() +} + +// discardCycle discards the results logged since mark, except those of the +// participants of the cycle in progress. If retain, the entries not undone +// stay in the log, as the outer cycle may still discard them. +func (c *Checker) discardCycle(mark int, retain bool) { + undo := c.discardLog[mark:] + participants := c.cycleParticipants + keep := make(map[*memoHeader]struct{}, len(participants)) + for _, p := range participants { + if p != nil { + keep[p] = struct{}{} + } + } + n := mark + for i := len(undo) - 1; i >= 0; i-- { + u := undo[i] + if u.effects { + // A result recomputed after the cycle also replays the effects + // of the computation discarded here. + continue + } + if _, ok := keep[u.memo]; ok && u.memo != nil { + continue + } + if u.drop != nil { + u.drop.dropped = true + } + u.restore() + undo[i] = discardEntry{} + } + if retain { + for _, u := range undo { + if u.restore != nil { + c.discardLog[n] = u + n++ + } + } + } + clear(c.discardLog[n:]) + c.discardLog = c.discardLog[:n] +} + +// extendCircularity makes the resolution at index head-1 part of the cycle in +// progress, starting one if there is none. A cycle whose head is inside the +// one in progress is an inner cycle: what is computed from its head while it +// is incomplete is discarded when it finishes, as for the outermost, rather +// than read by the rest of the outer cycle. +func (c *Checker) extendCircularity(head int) { + if c.typeResolutionTop != 0 { + c.observedHead = minObservedHead(c.observedHead, int32(head)) + } + c.recordFromCheck() + switch { + case c.circularityStart == 0: + c.circularityMark = len(c.discardLog) + c.circularityStart = head + case head < c.circularityStart: + c.addInnerCycle(c.circularityStart, c.circularityMark) + c.circularityStart = head + case head > c.circularityStart: + c.addInnerCycle(head, len(c.discardLog)) + } +} + +type innerCycle struct { + head int // As Checker.circularityStart + mark int // Length of the discard log when detected +} + +func (c *Checker) addInnerCycle(head int, mark int) { + for _, ic := range c.innerCycles { + if ic.head == head { + return + } + } + c.innerCycles = append(c.innerCycles, innerCycle{head, mark}) +} + +// dropResolution removes the resolution at index n, the top of the stack, and +// ends the cycles it was the head of. +func (c *Checker) dropResolution(n int) { + debug.Assert(n == len(c.resolutions)-1, "resolution dropped below the top") + c.unlinkResolution(&c.resolutions[n]) + c.resolutions[n] = resolution{} + c.resolutions = c.resolutions[:n] + if int(c.readIncompleteFloor) >= n { + c.readIncompleteFloor = 0 + } + c.endCyclesAt(n) +} + +// endCyclesAt ends the cycles whose head is the resolution at index n, which +// just finished. +func (c *Checker) endCyclesAt(n int) { + if c.circularityStart > n { + c.endCircularity() + } else if len(c.innerCycles) != 0 { + c.endInnerCycles(n) + } +} + +// endInnerCycles ends the inner cycles whose head is the resolution at index +// n, which just finished. +func (c *Checker) endInnerCycles(n int) { + for i, ic := range slices.Backward(c.innerCycles) { + if ic.head > n { + c.innerCycles = slices.Delete(c.innerCycles, i, i+1) + c.discardCycle(min(ic.mark, len(c.discardLog)), true) + } + } +} + +// A discardMark is a position in the computation in progress to which it can +// discard, so that it can run again from the same state, as if what it +// computed since had never run. From markDiscard to releaseDiscardMark, the +// discard log logs all that may have to be discarded. +type discardMark struct { + discardPoint + effectsMarkDepth int // Checker.effectsMarkDepth to restore on release + + // The effects recorded so far by the innermost computation in progress, + // which must have a memo resolution. + recording *memoEffects + effects int + deps int + resolutionIndex int +} + +func (c *Checker) markDiscard() discardMark { + c.recordFromCheck() + n := c.memoTop - 1 + f := c.memoEffectsAt(n) + m := discardMark{ + discardPoint: c.discardPoint(), + effectsMarkDepth: c.effectsMarkDepth, + recording: f, + effects: len(f.effects), + deps: len(f.deps), + resolutionIndex: n, + } + c.effectsMarkDepth = n + 1 + return m +} + +// discardSince discards the results cached since m, with the effects of +// computing them, restoring the cycle in progress then, and discards the +// effects recorded by the computation in progress. +func (c *Checker) discardSince(m discardMark) { + c.discardTo(m.discardPoint) + debug.Assert(c.memoTop-1 == m.resolutionIndex && c.resolutions[m.resolutionIndex].effects == m.recording, "effects discarded outside their computation") + m.recording.truncate(m.effects, m.deps) +} + +// A discardPoint is a position in the computation in progress to which what +// it caches since can be discarded. +type discardPoint struct { + discardLog int + participants int + circularityStart int +} + +func (c *Checker) discardPoint() discardPoint { + return discardPoint{discardLog: len(c.discardLog), participants: len(c.cycleParticipants), circularityStart: c.circularityStart} +} + +// discardTo discards the results cached since p, with the effects of +// computing them, restoring the cycle in progress then. +func (c *Checker) discardTo(p discardPoint) { + c.discardLogSince(p.discardLog) + c.cycleParticipants = c.cycleParticipants[:min(p.participants, len(c.cycleParticipants))] + c.circularityStart = p.circularityStart +} + +// truncate discards the effects recorded in f since it had the given numbers +// of effects and dependencies. +func (f *memoEffects) truncate(effects int, deps int) { + clear(f.effects[effects:]) + f.effects = f.effects[:effects] + f.truncateDeps(deps) +} + +// releaseDiscardMark ends the period during which the computation in progress +// can discard to m. +func (c *Checker) releaseDiscardMark(m discardMark) { + c.effectsMarkDepth = m.effectsMarkDepth + c.trimDiscardLog() + c.resumeChecking() +} + +func (f *memoEffects) truncateDeps(n int) { + for _, d := range f.deps[n:] { + if d.parent == f { + d.parent = nil + } + } + clear(f.deps[n:]) + f.deps = f.deps[:n] + if rare := f.rare; rare != nil { + for len(rare.cycles) != 0 && int(rare.cycles[len(rare.cycles)-1].dep) >= n { + rare.cycles = rare.cycles[:len(rare.cycles)-1] + } + } +} + +// logPendingDiscard logs the effects of the result in the memo state, which +// are about to change, so discardSince can restore them. +// +//go:noinline +func (c *Checker) logPendingDiscard(state *memoState) { + old := state.pending + n := 0 + if old != nil { + n = len(old.deps) + } + c.discardLog = append(c.discardLog, discardEntry{effects: true, restore: func() { + switch { + case old == nil && state.pending != nil: + c.memoPendingCount-- + c.syncObserving() + case old != nil && state.pending == nil: + c.memoPendingCount++ + c.syncObserving() + } + state.pending = old + // Only a set of deps (see linkState) gains deps through its state. + if old != nil && !old.entered && len(old.deps) > n { + old.truncateDeps(n) + } + }}) +} + +// Instantiation limits +// +// Instantiation stops with an error when nested too deeply or after too +// many instantiations, as the instantiation is then very likely infinite. +// For the result not to depend on what was cached before, each memoized +// computation (including each cached comparison of two types) measures +// depth from where it started, whether or not it reports errors, and a +// reused result adds no depth. +// +// Chains that start a new memoized computation at every level are only +// stopped by a limit on the depth of the whole instantiation stack, which +// is there to stop infinite instantiations rather than to judge finite +// ones: caching only ever shortens the stack, so an instantiation that +// would stay below it if computed from scratch stays below it in any order. +// An instantiation reaching it fails as a whole, with the instantiations in +// progress in the innermost computation other than of a cached +// instantiation, and the results cached since are discarded, so no part of +// an infinite instantiation is cached as though it were complete. Such a +// computation, like resolving the type arguments of a deferred type +// reference, is computed whenever first needed, inside an instantiation or +// not, so failing only its own instantiations makes the failure the same +// wherever it is reached. The error reported for it is carried by the +// results computed with it, and replaying it fails nothing, as computing +// those results again would fail only within them. Each cached +// instantiation in progress when one fails would fail too if computed from +// scratch, so it is recorded as failing, rather than computed again to the +// limit wherever it is reached. +// +// The limit on the number of instantiations is only reached by runaway +// instantiations, and depends on what was cached before: it counts +// the instantiations performed since the start of the current statement or +// expression, or of the outermost computation in progress, and reused +// results add none. Making it independent would mean +// keeping, for every cached result, the work needed to compute it from +// scratch, which costs far more than the limit is worth. + +// Heights +// +// Some computations give up beyond a limit on how deeply they nest, counted +// from the outermost one in progress, so a result computed inside another +// computation can differ from the same result computed on its own. A height +// is the number of levels a computation went below its own, kept with a +// cached result so that a computation reusing the result can tell whether +// computing it again there would reach the limit; see "Base constraint +// walks" and "Reusing failures". + +// height saturates at its maximum, which is above every limit it is +// compared with. +type height uint8 + +func heightOf[T ~int | ~int32](levels T) height { + return height(min(levels, math.MaxUint8)) +} + +// below returns the height of a computation with a computation of height h +// one level below it. +func (h height) below() height { + if h == math.MaxUint8 { + return h + } + return h + 1 +} + +// reaches reports whether a computation of height h, started at depth, +// reaches limit. +func (h height) reaches(depth int, limit int) bool { + return depth+int(h) >= limit +} + +const ( + instantiationDepthLimit = 100 + instantiationStackLimit = 1000 + instantiationCountLimit = 5_000_000 +) + +func (c *Checker) instantiationDepthLimitReached() bool { + return len(c.instantiationStack)-int(c.currentResolution().depthStart) == instantiationDepthLimit +} + +// instantiationTooDeep is the error reported for an instantiation that +// reached instantiationStackLimit. +var instantiationTooDeep = ¤tNodeError{func(c *Checker, node *ast.Node) { + c.error(node, diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) +}} + +// abortInstantiation fails the instantiations in progress in the innermost +// computation other than of a cached instantiation; see "Instantiation +// limits". +func (c *Checker) abortInstantiation() { + if c.instantiationAborted { + return + } + root := c.instantiationRoot() + if int(c.resolutions[root].depthStart) == len(c.instantiationStack) { + // No instantiation of the root is in progress. + c.reportNode(instantiationTooDeep) + return + } + c.instantiationAborted = true + c.instantiationAbortRoot = int(c.resolutions[root].depthStart) + c.instantiationAbortLog = len(c.discardLog) + // Each cached instantiation in progress reached the limit, and would + // again if computed from scratch, so it is known to fail without + // computing it again. + for i := root + 1; i < len(c.resolutions); i++ { + if f := &c.resolutions[i]; f.instantiation { + if c.tooDeepInstantiations == nil { + c.tooDeepInstantiations = make(map[memoKey]struct{}) + } + c.tooDeepInstantiations[f.key] = struct{}{} + } + } +} + +// beginInstantiation is called after beginning the computation of a cached +// instantiation, and reports whether it is known to fail, in which case it +// fails as computing it would. +func (c *Checker) beginInstantiation() bool { + f := c.currentResolution() + f.instantiation = true + if len(c.tooDeepInstantiations) == 0 { + return false + } + if _, ok := c.tooDeepInstantiations[f.key]; !ok { + return false + } + c.abortInstantiation() + return true +} + +// instantiationRoot returns the index in resolutions of the innermost +// computation in progress other than of a cached instantiation, whose +// instantiations fail together when one reaches instantiationStackLimit; see +// "Instantiation limits". A type or node resolution is part of the +// computation below it, with the same serial. +func (c *Checker) instantiationRoot() int { + for i := len(c.resolutions) - 1; i > 0; i-- { + if f := &c.resolutions[i]; !f.instantiation && f.serial != c.resolutions[i-1].serial { + return i + } + } + return 0 +} + +// endInstantiation is called when the computation of a cached instantiation +// finishes, and reports whether to cache its result. An instantiation +// finishing while instantiations in progress are failing is part of the +// failure, and is not cached, since the instantiation caches keep the +// identity of what they cache and so are not discarded with the results +// cached since the failure. It then ends the computation itself. +func (c *Checker) endInstantiation(reports currentNodeErrorsMark) bool { + if !c.instantiationAborted { + return true + } + c.endCurrentNodeErrors(reports) + c.endMemoUncached() + return false +} + +// endInstantiationAbort finishes failing the instantiations of the innermost +// computation, once they have unwound. +func (c *Checker) endInstantiationAbort() { + c.instantiationAborted = false + c.instantiationAbortRoot = 0 + c.discardLogSince(c.instantiationAbortLog) + c.instantiationAbortLog = 0 + c.trimDiscardLog() + c.reportNode(instantiationTooDeep) +} + +// A Relation caches the results of comparisons. +type Relation struct { + results memoMap[CacheHashKey, RelationComparisonResult] +} + +func (r *Relation) size() int { + return len(r.results.memoEntries) +} + +func (r *Relation) cached(c *Checker, key CacheHashKey) RelationComparisonResult { + result, _ := r.results.cached(c, key) + return result +} + +func (r *Relation) set(c *Checker, key CacheHashKey, result RelationComparisonResult) { + r.results.set(c, key, result) +} + +// begin starts the comparison computing the result for key. +func (r *Relation) begin(c *Checker, key CacheHashKey) { + r.results.begin(c, key) +} diff --git a/tsc/internal/checker/memopeek_test.go b/tsc/internal/checker/memopeek_test.go new file mode 100644 index 0000000000000..a04771b16f693 --- /dev/null +++ b/tsc/internal/checker/memopeek_test.go @@ -0,0 +1,381 @@ +package checker_test + +import ( + goast "go/ast" + "go/parser" + "go/printer" + "go/token" + "path/filepath" + "strings" + "testing" + + "gotest.tools/v3/assert" +) + +// memoComputeCalls are the calls only the computation of a result makes on +// its memo: a function making one computes the results of that memo. +var memoComputeCalls = map[string]bool{ + "begin": true, "set": true, "setIdentity": true, "setReported": true, + "swap": true, "intern": true, "compute": true, "once": true, + "setAfterMarker": true, "setIfChanged": true, +} + +// memoReads are the calls reading what a memo holds. +var memoReads = map[string]bool{"cached": true, "hasCached": true, "peek": true} + +// memoHelpers are methods standing for a call on a memo whose storage is +// allocated only when needed: each names the memo field and whether the +// method reads it or computes it. +var memoHelpers = map[string]struct { + field string + reads bool +}{ + "cachedWriteType": {"writeType", true}, + "setWriteType": {"writeType", false}, + "setNewWriteType": {"writeType", false}, + "cachedOuterTypeParameters": {"outerTypeParameters", true}, +} + +// Whether a memo holds a result yet depends on what was computed first, so +// only the computation of a result reads it from its memo: its getter, which +// reuses it, and the computation itself. Everything else asks the getter. A +// memo a computation fills in as a side output of another has no getter of +// its own; it is read by the one accessor listed in memoAccessors, which runs +// the computation producing it first. +func TestOnlyComputationsReadMemos(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + text := func(e goast.Expr) string { + var b strings.Builder + printer.Fprint(&b, fset, e) + return b.String() + } + field := func(memo string) string { + return memo[strings.LastIndexByte(memo, '.')+1:] + } + for _, name := range files { + // Memos and the resolutions computing them are implemented in + // memo.go and resolutions.go, which find computations in progress. + // Tracing reports what has been computed without computing more, + // and its output is not the checker's. + if name == "memo.go" || name == "resolutions.go" || name == "tracer.go" || strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + if _, ok := memoHelpers[fn.Name.Name]; ok && fn.Recv != nil { + continue + } + computes := make(map[string]bool) + computesAny := false + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + switch f := call.Fun.(type) { + case *goast.SelectorExpr: + if memoComputeCalls[f.Sel.Name] { + computes[text(f.X)] = true + } + if h, ok := memoHelpers[f.Sel.Name]; ok && !h.reads { + computes[text(f.X)+"."+h.field] = true + } + // Computations keyed by entity and field begin by key. + if f.Sel.Name == "beginMemo" || f.Sel.Name == "memoCompute" || f.Sel.Name == "objectFlagsCell" { + computesAny = true + } + case *goast.Ident, *goast.IndexExpr: + callee := text(call.Fun) + if i := strings.IndexByte(callee, '['); i >= 0 { + callee = callee[:i] + } + if memoComputeCalls[callee] && len(call.Args) > 1 { + if u, ok := call.Args[1].(*goast.UnaryExpr); ok { + computes[text(u.X)] = true + } + } + } + return true + }) + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok { + return true + } + var memo string + if h, ok := memoHelpers[sel.Sel.Name]; ok && h.reads { + memo = text(sel.X) + "." + h.field + } else if memoReads[sel.Sel.Name] { + memo = text(sel.X) + } else { + return true + } + if computes[memo] || computesAny || memoAccessors[field(memo)][fn.Name.Name] { + return true + } + t.Errorf("%s: %s reads %s, whose results it does not compute", fset.Position(call.Pos()), fn.Name.Name, memo) + return true + }) + } + } +} + +// memoAccessors lists, for each memo filled in as a side output of another +// computation, the accessors reading it, which run that computation first or +// are called by it once it has; and for each memo holding a part an entity's +// creator supplies, the accessor reading that part. +var memoAccessors = map[string]map[string]bool{ + "resolvedTypeArguments": {"typeArgumentsOfCreation": true}, + "writeType": {"writeTypeOfCreation": true}, + "resolvedType": {"typeOfCreation": true}, + "constraint": {"constraintOfCreation": true}, + "containsError": {"mappedTypeContainsError": true}, + "resolvedSymbol": { + "getSymbolOfExpression": true, "symbolOfCheckedExpression": true, + "getSymbolOfTypeNodePart": true, + }, + "lateMergedSymbols": {"getLateMergedSymbol": true, "combineSymbolTables": true}, + "relation": {"cachedRelation": true}, +} + +// A result an entity's creator sets is part of the entity, which can outlive +// the computation creating it in caches, with no way to compute the result +// again. So the creator sets it with setIdentity or intern, which are kept, +// and not with set, which a discarded computation discards. +func TestCreatorsKeepThePartsTheySet(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + text := func(e goast.Expr) string { + var b strings.Builder + printer.Fprint(&b, fset, e) + return b.String() + } + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + // The entities the function creates, and the links of those. + created := make(map[string]bool) + goast.Inspect(fn.Body, func(n goast.Node) bool { + assign, ok := n.(*goast.AssignStmt) + if !ok || len(assign.Lhs) != 1 || len(assign.Rhs) != 1 { + return true + } + call, ok := assign.Rhs[0].(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok { + return true + } + isNew := strings.HasPrefix(sel.Sel.Name, "new") && text(sel.X) == "c" + isLinks := sel.Sel.Name == "Get" && strings.HasSuffix(text(sel.X), "Links") && len(call.Args) == 1 && created[text(call.Args[0])] + if isNew || isLinks { + created[text(assign.Lhs[0])] = true + } + return true + }) + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok || sel.Sel.Name != "set" && sel.Sel.Name != "setWriteType" { + return true + } + // The memo is reached from a created entity or its links. + for e := sel.X; e != nil; { + switch x := e.(type) { + case *goast.SelectorExpr: + e = x.X + case *goast.CallExpr: + if s, ok := x.Fun.(*goast.SelectorExpr); ok && s.Sel.Name == "Get" && len(x.Args) == 1 && created[text(x.Args[0])] { + t.Errorf("%s: %s sets part of %s, which it creates, with %s", fset.Position(call.Pos()), fn.Name.Name, text(x.Args[0]), sel.Sel.Name) + return true + } + e = x.Fun + case *goast.Ident: + if created[x.Name] { + t.Errorf("%s: %s sets part of %s, which it creates, with %s", fset.Position(call.Pos()), fn.Name.Name, x.Name, sel.Sel.Name) + } + e = nil + default: + e = nil + } + } + return true + }) + } + } +} + +// appliedCalls are the checker methods an effect may call when it is +// applied: those adding what was computed where the effect was recorded. +var appliedCalls = map[string]bool{ + "error": true, "addErrorOrSuggestion": true, "Add": true, "Has": true, "Get": true, + "IsTrue": true, +} + +// A query records the effects of a computation, and reports located at the +// node checking it, to apply them once checking reaches its result; checking +// applies them as they happen, inside the computation. So an effect, and a +// report, only applies what was computed where it was recorded: computing +// more when applied, such as printing a type, would run inside the +// computation in a check but after it in a query, and could find +// computations in progress in one and not in the other. +func TestDeferredEffectsOnlyApply(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + text := func(e goast.Expr) string { + var b strings.Builder + printer.Fprint(&b, fset, e) + return b.String() + } + funcs := make(map[string]*goast.FuncDecl) + var parsed []*goast.File + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + parsed = append(parsed, file) + for _, decl := range file.Decls { + if fn, ok := decl.(*goast.FuncDecl); ok && fn.Recv != nil && fn.Body != nil { + funcs[fn.Name.Name] = fn + } + } + } + // check reports the calls in body of checker methods not adding what + // was computed. A method recording an effect that calls the method + // again applies the rest of its body. + var check func(owner *goast.FuncDecl, body goast.Node, where token.Pos) + check = func(owner *goast.FuncDecl, body goast.Node, where token.Pos) { + goast.Inspect(body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok { + return true + } + root := sel.X + for { + if s, ok := root.(*goast.SelectorExpr); ok { + root = s.X + } else { + break + } + } + if id, ok := root.(*goast.Ident); !ok || id.Name != "c" { + return true + } + // A deferred diagnostic is produced when the check ends, outside + // the computations in progress, in a check and in a query alike. + if sel.Sel.Name == "addDeferredDiagnostic" { + return false + } + // The program computes nothing in the checker. + if appliedCalls[sel.Sel.Name] || text(sel.X) == "c.program" { + return true + } + if sel.Sel.Name == owner.Name.Name && text(sel.X) == "c" { + for _, stmt := range owner.Body.List { + if !recordsEffect(stmt) { + check(owner, stmt, where) + } + } + return true + } + t.Errorf("%s: an effect recorded by %s calls %s when applied", fset.Position(where), owner.Name.Name, text(call.Fun)) + return true + }) + } + for _, file := range parsed { + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + // Closures the function assigns to names. + closures := make(map[string]*goast.FuncLit) + goast.Inspect(fn.Body, func(n goast.Node) bool { + if assign, ok := n.(*goast.AssignStmt); ok && len(assign.Lhs) == 1 && len(assign.Rhs) == 1 { + if lit, ok := assign.Rhs[0].(*goast.FuncLit); ok { + closures[text(assign.Lhs[0])] = lit + } + } + return true + }) + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok || len(call.Args) == 0 { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok || text(sel.X) != "c" || !deferringCalls[sel.Sel.Name] { + return true + } + var lit *goast.FuncLit + switch arg := call.Args[len(call.Args)-1].(type) { + case *goast.FuncLit: + lit = arg + case *goast.Ident: + lit = closures[arg.Name] + } + if lit != nil { + check(fn, lit.Body, call.Pos()) + } + return true + }) + } + } +} + +// deferringCalls are the checker methods taking an effect, or a report, +// that a query applies later than checking does. +var deferringCalls = map[string]bool{ + "recordEffect": true, "recordMark": true, "reportAtCurrentNode": true, "reportAtCurrentNodeOnce": true, + "holdEffect": true, +} + +// recordsEffect reports whether stmt is the part of a method recording an +// effect that records it. +func recordsEffect(stmt goast.Stmt) bool { + found := false + goast.Inspect(stmt, func(n goast.Node) bool { + if call, ok := n.(*goast.CallExpr); ok { + if sel, ok := call.Fun.(*goast.SelectorExpr); ok && deferringCalls[sel.Sel.Name] { + found = true + } + } + return !found + }) + return found +} diff --git a/tsc/internal/checker/nodebuilder_hover.go b/tsc/internal/checker/nodebuilder_hover.go index b49ac981fbd41..9abe67c6b1ed4 100644 --- a/tsc/internal/checker/nodebuilder_hover.go +++ b/tsc/internal/checker/nodebuilder_hover.go @@ -263,7 +263,7 @@ func (b *NodeBuilderImpl) expandInterfaceDecl(symbol *ast.Symbol) *ast.Node { members = append(members, b.signatureToSignatureDeclarationHelper(sig, ast.KindCallSignature, nil)) } // Properties, filtering inherited - filteredProps := b.filterInheritedProperties(interfaceType, baseTypes, resolved.getProperties()) + filteredProps := b.filterInheritedProperties(interfaceType, baseTypes, resolved.getProperties(b.ch)) members = b.serializePropertiesWithTruncation(filteredProps, members) // Heritage clauses diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 2d2d01e83affa..a8ddb707d9342 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -476,7 +476,7 @@ func (b *NodeBuilderImpl) serializeTypeName(node *ast.Node, isTypeOf bool, typeA if isTypeOf { meaning = ast.SymbolFlagsValue } - symbol := b.ch.resolveEntityName(node, meaning, true, false, node) + symbol := b.ch.resolveEntityNameEx(node, meaning, true, false, node, false /*use*/) if symbol == nil { return nil } @@ -544,13 +544,7 @@ func (b *NodeBuilderImpl) tryGetResolvedSymbolFromTypeNode(node *ast.Node) *ast. if node == nil || node.Parent == nil { return nil } - b.ch.getTypeFromTypeNode(node) - // call to ensure symbol is resolved - links := b.ch.symbolNodeLinks.TryGet(node) - if links == nil { - return nil - } - return links.resolvedSymbol + return b.ch.getSymbolOfTypeNode(node) } func (b *NodeBuilderImpl) existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing *ast.TypeNode, t *Type) bool { @@ -607,7 +601,7 @@ func (b *NodeBuilderImpl) getResolvedTypeWithoutAbstractConstructSignatures(t *S t.extra.objectTypeWithoutAbstractConstructSignatures = t.AsType() return t.AsType() } - typeCopy := b.ch.newAnonymousType(t.symbol, t.getMembers(), t.CallSignatures(), core.IfElse(len(constructSignatures) > 0, constructSignatures, []*Signature{}), t.getIndexInfos()) + typeCopy := b.ch.newAnonymousType(t.symbol, t.getMembers(b.ch), t.CallSignatures(), core.IfElse(len(constructSignatures) > 0, constructSignatures, []*Signature{}), t.getIndexInfos()) t.extra.objectTypeWithoutAbstractConstructSignatures = typeCopy typeCopy.AsStructuredType().ensureExtra().objectTypeWithoutAbstractConstructSignatures = typeCopy return typeCopy @@ -2097,9 +2091,9 @@ func (c *Checker) getExpandedParameters(sig *Signature, skipUnionExpanding bool) symbol := c.newSymbolEx(ast.SymbolFlagsFunctionScopedVariable, name, checkFlags) links := c.valueSymbolLinks.Get(symbol) if flags&ElementFlagsRest != 0 { - links.resolvedType = c.createArrayType(t) + links.resolvedType.setIdentity(c, c.createArrayType(t)) } else { - links.resolvedType = t + links.resolvedType.setIdentity(c, t) } return symbol }) @@ -2483,12 +2477,12 @@ func (b *NodeBuilderImpl) shouldUsePlaceholderForProperty(propertySymbol *ast.Sy func (b *NodeBuilderImpl) trackComputedName(accessExpression *ast.Node, enclosingDeclaration *ast.Node) { // get symbol of the first identifier of the entityName firstIdentifier := ast.GetFirstIdentifier(accessExpression) - name := b.ch.resolveName(enclosingDeclaration, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, true /*isUse*/, false) + name := b.ch.resolveName(enclosingDeclaration, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, false /*isUse*/, false) if name != nil { b.ctx.tracker.TrackSymbol(name, enclosingDeclaration, ast.SymbolFlagsValue) } else { // Name does not resolve at target location, track symbol at dest location (should be inaccessible) - fallback := b.ch.resolveName(firstIdentifier, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, true /*isUse*/, false) + fallback := b.ch.resolveName(firstIdentifier, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, false /*isUse*/, false) if fallback != nil { b.ctx.tracker.TrackSymbol(fallback, enclosingDeclaration, ast.SymbolFlagsValue) } @@ -2625,6 +2619,16 @@ func (b *NodeBuilderImpl) getPropertyNameNodeForSymbolFromNameType(symbol *ast.S return nil } +// approximateNameLength returns the length of a property name, without the +// symbol ID a late-bound name ends with, which depends on when the symbol was +// created and so would make truncation depend on the order of checking. +func approximateNameLength(name string) int { + if isLateBoundName(name) { + return strings.LastIndexByte(name, '@') + } + return len(name) +} + func (b *NodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, typeElements []*ast.TypeElement) []*ast.TypeElement { propertyIsReverseMapped := propertySymbol.CheckFlags()&ast.CheckFlagsReverseMapped != 0 var propertyType *Type @@ -2661,7 +2665,7 @@ func (b *NodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, t } propertyName := b.getPropertyNameNodeForSymbol(propertySymbol, saveEnclosingDeclaration) b.ctx.enclosingDeclaration = saveEnclosingDeclaration - b.ctx.approximateLength += len(ast.SymbolName(propertySymbol)) + 1 + b.ctx.approximateLength += approximateNameLength(ast.SymbolName(propertySymbol)) + 1 if propertySymbol.Flags()&ast.SymbolFlagsAccessor != 0 { writeType := b.ch.getWriteTypeOfSymbol(propertySymbol) @@ -2703,7 +2707,7 @@ func (b *NodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, t typeElements = append(typeElements, fakeGetterDeclaration) setterParam := b.ch.newSymbol(ast.SymbolFlagsFunctionScopedVariable, "arg") - b.ch.valueSymbolLinks.Get(setterParam).resolvedType = writeType + b.ch.valueSymbolLinks.Get(setterParam).resolvedType.set(b.ch, writeType) fakeSetterSignature := b.ch.newSignature(SignatureFlagsNone, nil, nil, nil, []*ast.Symbol{setterParam}, b.ch.voidType, nil, 0) fakeSetterDeclaration := b.signatureToSignatureDeclarationHelper(fakeSetterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{ name: propertyName, @@ -2792,7 +2796,7 @@ func (b *NodeBuilderImpl) createTypeNodesFromResolvedType(resolvedType *Structur typeElements = slices.Concat(typeElements, b.indexInfoToObjectComputedNamesOrSignatureDeclaration(info, typeNode)) } - properties := resolvedType.getProperties() + properties := resolvedType.getProperties(b.ch) if len(properties) == 0 { return b.f.NewNodeList(typeElements) } @@ -2834,14 +2838,14 @@ func (b *NodeBuilderImpl) createTypeNodesFromResolvedType(resolvedType *Structur } func (b *NodeBuilderImpl) createTypeNodeFromObjectType(t *Type) *ast.TypeNode { - if b.ch.isGenericMappedType(t) || (t.objectFlags&ObjectFlagsMapped != 0 && t.AsMappedType().containsError) { + if b.ch.isGenericMappedType(t) || (t.objectFlags&ObjectFlagsMapped != 0 && b.ch.mappedTypeContainsError(t)) { return b.createMappedTypeNodeFromType(t) } resolved := b.ch.resolveStructuredTypeMembers(t) callSigs := resolved.CallSignatures() ctorSigs := resolved.ConstructSignatures() - if len(resolved.getProperties()) == 0 && len(resolved.getIndexInfos()) == 0 { + if len(resolved.getProperties(b.ch)) == 0 && len(resolved.getIndexInfos()) == 0 { if len(callSigs) == 0 && len(ctorSigs) == 0 { b.ctx.approximateLength += 2 result := b.f.NewTypeLiteralNode(b.f.NewNodeList([]*ast.Node{})) @@ -2870,9 +2874,9 @@ func (b *NodeBuilderImpl) createTypeNodeFromObjectType(t *Type) *ast.TypeNode { return b.ch.getOrCreateTypeFromSignature(s) }) // count the number of type elements excluding abstract constructors - typeElementCount := len(callSigs) + (len(ctorSigs) - len(abstractSignatures)) + len(resolved.getIndexInfos()) + core.IfElse(b.ctx.flags&nodebuilder.FlagsWriteClassExpressionAsTypeLiteral != 0, core.CountWhere(resolved.getProperties(), func(p *ast.Symbol) bool { + typeElementCount := len(callSigs) + (len(ctorSigs) - len(abstractSignatures)) + len(resolved.getIndexInfos()) + core.IfElse(b.ctx.flags&nodebuilder.FlagsWriteClassExpressionAsTypeLiteral != 0, core.CountWhere(resolved.getProperties(b.ch), func(p *ast.Symbol) bool { return p.Flags()&ast.SymbolFlagsPrototype == 0 - }), len(resolved.getProperties())) + }), len(resolved.getProperties(b.ch))) // don't include an empty object literal if there were no other static-side // properties to write, i.e. `abstract class C { }` becomes `abstract new () => {}` // and not `(abstract new () => {}) & {}` diff --git a/tsc/internal/checker/nodecopy.go b/tsc/internal/checker/nodecopy.go index 71ed761dcbdc8..c54113110b058 100644 --- a/tsc/internal/checker/nodecopy.go +++ b/tsc/internal/checker/nodecopy.go @@ -340,7 +340,7 @@ func getExistingNodeTreeVisitor(b *NodeBuilderImpl, bound *recoveryBoundary) *as } return introducesError, attachSymbolToLeftmostIdentifier(leftmost, node, sym), nil } - sym = b.ch.resolveEntityName(leftmost, meaning, true, true, nil) + sym = b.ch.resolveEntityNameEx(leftmost, meaning, true, true, nil, false /*use*/) if b.ctx.enclosingDeclaration != nil && !(sym != nil && sym.Flags()&ast.SymbolFlagsTypeParameter != 0) { sym = b.ch.getExportSymbolOfValueSymbolIfExported(sym) // Some declarations may be transplanted to a new location. @@ -348,14 +348,16 @@ func getExistingNodeTreeVisitor(b *NodeBuilderImpl, bound *recoveryBoundary) *as // We also check for the unknownSymbol because when we create a fake scope some parameters may actually not be usable // either because they are the expanded rest parameter, // or because they are the newly added parameters from the tuple, which might have different meanings in the original context - symAtLocation := b.ch.resolveEntityName(leftmost, meaning, true, true, b.ctx.enclosingDeclaration) + symAtLocation := b.ch.resolveEntityNameEx(leftmost, meaning, true, true, b.ctx.enclosingDeclaration, false /*use*/) if // Check for unusable parameters symbols symAtLocation == b.ch.unknownSymbol || // If the symbol is not found, but was not found in the original scope either we probably have an error, don't reuse the node (symAtLocation == nil && sym != nil) || - // If the symbol is found both in declaration scope and in current scope then it should point to the same reference - (symAtLocation != nil && sym != nil && b.ch.getSymbolIfSameReference(b.ch.getExportSymbolOfValueSymbolIfExported(symAtLocation), sym) == nil) { + // If the symbol is found both in declaration scope and in current scope then it should point to the same reference. + // A parameter in scope may be an instantiation of the one in the declaration, depending on whether + // its type was resolved before its signature was instantiated, so compare what they instantiate. + (symAtLocation != nil && sym != nil && b.ch.getSymbolIfSameReference(b.ch.getTargetSymbol(b.ch.getExportSymbolOfValueSymbolIfExported(symAtLocation)), b.ch.getTargetSymbol(sym)) == nil) { // In isolated declaration we will not do rest parameter expansion so there is no need to report on these. if symAtLocation != b.ch.unknownSymbol { b.ctx.tracker.ReportInferenceFallback(node) diff --git a/tsc/internal/checker/printer.go b/tsc/internal/checker/printer.go index b84c967883d88..c06d16d173323 100644 --- a/tsc/internal/checker/printer.go +++ b/tsc/internal/checker/printer.go @@ -60,7 +60,7 @@ func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags // Serialization of types can lead to (lazy) resolution of members, which can cause diagnostics that again require // serialization of types. This can potentially result in infinite recursion and stack overflows. To prevent that, // after a certain number of recursive invocations the function simply returns "?". - if c.serializationLevel >= maxSerializationLevel { + if c.depthLimitReached(&c.serializationLevel, maxSerializationLevel) { return "?" } newLine := "" @@ -80,9 +80,9 @@ func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags defer func() { nodeBuilder.verbosity = oldVerbosity }() - c.serializationLevel++ + c.enterDepthLimit(&c.serializationLevel) typeNode := nodeBuilder.TypeToTypeNode(t, enclosingDeclaration, combinedFlags, nodebuilder.InternalFlagsNone, nil) - c.serializationLevel-- + c.exitDepthLimit(&c.serializationLevel) if typeNode == nil { panic("should always get typenode") } diff --git a/tsc/internal/checker/pseudotypenodebuilder.go b/tsc/internal/checker/pseudotypenodebuilder.go index 8f1e2bf1700e1..8233c3543f889 100644 --- a/tsc/internal/checker/pseudotypenodebuilder.go +++ b/tsc/internal/checker/pseudotypenodebuilder.go @@ -699,6 +699,14 @@ func (b *NodeBuilderImpl) pseudoTypeToType(t *pseudochecker.PseudoType) *Type { return b.ch.getReturnTypeOfSignature(b.ch.getSignatureFromDeclaration(node)) } ty := b.ch.getWidenedType(b.ch.getRegularTypeOfExpression(node)) + if ast.IsPropertyAssignment(node.Parent) { + // pseudoTypeToNode serializes the type of the property's symbol, which is + // not widened in the context of its containing object literal. + declared := b.ch.getWidenedLiteralType(b.ch.getTypeOfSymbol(b.ch.getSymbolOfDeclaration(node.Parent))) + if declared != ty { + return nil + } + } return ty case pseudochecker.PseudoTypeKindNoResult: return nil // TODO: extract type selection logic from `serializeTypeForDeclaration`, not needed for current usecases but needed if completeness becomes required diff --git a/tsc/internal/checker/relater.go b/tsc/internal/checker/relater.go index 562ae0451cb43..3dfb42f047da4 100644 --- a/tsc/internal/checker/relater.go +++ b/tsc/internal/checker/relater.go @@ -10,6 +10,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/binder" "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/core" + "github.com/microsoft/TypeScript/tsc/internal/debug" "github.com/microsoft/TypeScript/tsc/internal/diagnostics" "github.com/microsoft/TypeScript/tsc/internal/jsnum" "github.com/microsoft/TypeScript/tsc/internal/stringutil" @@ -71,8 +72,11 @@ const ( RelationComparisonResultReportsUnmeasurable RelationComparisonResult = 1 << 3 RelationComparisonResultReportsUnreliable RelationComparisonResult = 1 << 4 RelationComparisonResultComplexityOverflow RelationComparisonResult = 1 << 5 - RelationComparisonResultReportsMask = RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable - RelationComparisonResultOverflow = RelationComparisonResultComplexityOverflow + // The comparison observed incomplete variances; see getRecursiveVariances. + // Only reported, never cached. + RelationComparisonResultReportsIncomplete RelationComparisonResult = 1 << 6 + RelationComparisonResultReportsMask = RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable + RelationComparisonResultOverflow = RelationComparisonResultComplexityOverflow ) type DiagnosticAndArguments struct { @@ -96,23 +100,13 @@ func asRecursionId[T *ast.Node | *ast.Symbol | *Type](value T) RecursionId { return RecursionId{value: value} } -type Relation struct { - results map[CacheHashKey]RelationComparisonResult -} - -func (r *Relation) get(key CacheHashKey) RelationComparisonResult { - return r.results[key] -} +// relationCountLimit is the number of results a single comparison may add to +// a relation before it is considered too complex. +const relationCountLimit = 16_000_000 / 8 -func (r *Relation) set(key CacheHashKey, result RelationComparisonResult) { - if r.results == nil { - r.results = make(map[CacheHashKey]RelationComparisonResult) - } - r.results[key] = result -} - -func (r *Relation) size() int { - return len(r.results) +// relationKeyBits returns well-mixed bits of a relation key, which is a hash. +func relationKeyBits(k CacheHashKey) uint64 { + return k.Lo } func (c *Checker) isTypeIdenticalTo(source *Type, target *Type) bool { @@ -167,6 +161,25 @@ func (c *Checker) areTypesComparable(type1 *Type, type2 *Type) bool { return c.isTypeComparableTo(type1, type2) || c.isTypeComparableTo(type2, type1) } +// reuseRelation returns the result of a comparison cached as entry, if it can +// be reused, accounting for what the comparison reported about the reliability +// of the variances it used, as computing it would. +func (c *Checker) reuseRelation(entry RelationComparisonResult) (related bool, ok bool) { + if entry == RelationComparisonResultNone || entry&RelationComparisonResultOverflow != 0 { + return false, false + } + c.reliabilityFlags |= entry & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) + return entry&RelationComparisonResultSucceeded != 0, true +} + +// cachedRelation returns the result cached for the comparison id, and whether +// it is related, if it can be reused; see reuseRelation. +func (c *Checker) cachedRelation(relation *Relation, id CacheHashKey) (entry RelationComparisonResult, related bool, ok bool) { + entry = relation.cached(c, id) + related, ok = c.reuseRelation(entry) + return entry, related, ok +} + func (c *Checker) isTypeRelatedTo(source *Type, target *Type, relation *Relation) bool { if isFreshLiteralType(source) { source = source.AsLiteralType().regularType @@ -191,11 +204,14 @@ func (c *Checker) isTypeRelatedTo(source *Type, target *Type, relation *Relation } } if source.flags&TypeFlagsObject != 0 && target.flags&TypeFlagsObject != 0 { - id, _ := getRelationKey(source, target, IntersectionStateNone, relation == c.identityRelation, false) - related := relation.get(id) - if related != RelationComparisonResultNone { - return related&RelationComparisonResultSucceeded != 0 + id, constrained := c.getRelationKey(source, target, IntersectionStateNone, relation == c.identityRelation, false) + // An overflow is reported by each comparison that reaches it, so it + // is left to checkTypeRelatedTo. + related, result, ok := c.cachedRelation(relation, id) + if ok { + return result } + return c.checkTypeRelatedToWithKey(source, target, relation, nil /*errorNode*/, nil, nil, true, id, constrained, related) } if source.flags&TypeFlagsStructuredOrInstantiable != 0 || target.flags&TypeFlagsStructuredOrInstantiable != 0 { return c.checkTypeRelatedTo(source, target, relation, nil /*errorNode*/) @@ -289,9 +305,22 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er return false } key := EnumRelationKey{sourceId: ast.GetSymbolId(sourceSymbol), targetId: ast.GetSymbolId(targetSymbol)} - if entry := c.enumRelation[key]; entry != RelationComparisonResultNone && !(entry&RelationComparisonResultFailed != 0 && errorReporter != nil) { - return entry&RelationComparisonResultSucceeded != 0 - } + entry, _ := c.enumRelation.cached(c, key) + if entry != RelationComparisonResultNone { + if entry&RelationComparisonResultFailed == 0 || errorReporter == nil { + return entry&RelationComparisonResultSucceeded != 0 + } + // Recompute a cached failure only to elaborate it. + return c.isEnumTypeRelatedToUncached(sourceSymbol, targetSymbol, errorReporter) + } + c.enumRelation.begin(c, key) + related := c.isEnumTypeRelatedToUncached(sourceSymbol, targetSymbol, errorReporter) + c.enumRelation.set(c, key, core.IfElse(related, RelationComparisonResultSucceeded, RelationComparisonResultFailed)) + c.endMemo() + return related +} + +func (c *Checker) isEnumTypeRelatedToUncached(sourceSymbol *ast.Symbol, targetSymbol *ast.Symbol, errorReporter ErrorReporter) bool { targetEnumType := c.getTypeOfSymbol(targetSymbol) for _, sourceProperty := range c.getPropertiesOfType(c.getTypeOfSymbol(sourceSymbol)) { if sourceProperty.Flags()&ast.SymbolFlagsEnumMember != 0 { @@ -300,7 +329,6 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er if errorReporter != nil { errorReporter(diagnostics.Property_0_is_missing_in_type_1, c.symbolToString(sourceProperty), c.TypeToStringEx(c.getDeclaredTypeOfSymbol(targetSymbol), nil /*enclosingDeclaration*/, TypeFormatFlagsUseFullyQualifiedType, nil)) } - c.enumRelation[key] = RelationComparisonResultFailed return false } sourceValue := c.getEnumMemberValue(ast.GetDeclarationOfKind(sourceProperty, ast.KindEnumMember)).Value @@ -311,7 +339,6 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er if errorReporter != nil { errorReporter(diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given, c.symbolToString(targetSymbol), c.symbolToString(targetProperty), c.valueToString(targetValue), c.valueToString(sourceValue)) } - c.enumRelation[key] = RelationComparisonResultFailed return false } // At this point we know that at least one of the values is 'undefined'. @@ -327,13 +354,11 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er knownStringValue := core.OrElse(sourceValue, targetValue) errorReporter(diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value, c.symbolToString(targetSymbol), c.symbolToString(targetProperty), c.valueToString(knownStringValue)) } - c.enumRelation[key] = RelationComparisonResultFailed return false } } } } - c.enumRelation[key] = RelationComparisonResultSucceeded return true } @@ -363,23 +388,66 @@ func (c *Checker) checkTypeRelatedToEx( errorNode *ast.Node, headMessage *diagnostics.Message, diagnosticOutput *[]*ast.Diagnostic, +) bool { + return c.checkTypeRelatedToWithKey(source, target, relation, errorNode, headMessage, diagnosticOutput, false, CacheHashKey{}, false, RelationComparisonResultNone) +} + +// checkTypeRelatedToWithKey is checkTypeRelatedToEx given, if hasKey, the +// relation key of source and target, as returned by getRelationKey, and the +// result cached under it. +func (c *Checker) checkTypeRelatedToWithKey( + source *Type, + target *Type, + relation *Relation, + errorNode *ast.Node, + headMessage *diagnostics.Message, + diagnosticOutput *[]*ast.Diagnostic, + hasKey bool, + id CacheHashKey, + constrained bool, + entry RelationComparisonResult, ) bool { r := c.getRelater() r.relation = relation r.errorNode = errorNode - r.relationCount = (16_000_000 - relation.size()) / 8 - result := r.isRelatedToEx(source, target, RecursionFlagsBoth, errorNode != nil /*reportErrors*/, headMessage, IntersectionStateNone) + // The budget does not depend on how many results are cached, so that whether + // a comparison overflows does not depend on what was compared before it. + r.relationCount = relationCountLimit + r.topSource, r.topTarget = source, target + if hasKey { + r.topKey, r.topConstrained, r.topHasKey = id, constrained, true + r.topEntry, r.topEntryWrites, r.topEntryRead = entry, relation.results.writes, true + } + var result Ternary + if entry&RelationComparisonResultOverflow != 0 { + // The comparison overflowed before, and would again. + r.overflow = true + } else { + saveIncomplete := c.reliabilityFlags & RelationComparisonResultReportsIncomplete + c.reliabilityFlags &^= RelationComparisonResultReportsIncomplete + result = r.isRelatedToEx(source, target, RecursionFlagsBoth, errorNode != nil /*reportErrors*/, headMessage, IntersectionStateNone) + c.reliabilityFlags = c.reliabilityFlags&^RelationComparisonResultReportsIncomplete | saveIncomplete + if r.topBegun { + if r.overflow { + // Record this relation as having failed such that we don't attempt the overflowing operation again. + relation.set(c, r.topKey, RelationComparisonResultFailed|RelationComparisonResultComplexityOverflow) + } + c.endMemo() + } + } if r.overflow { - // Record this relation as having failed such that we don't attempt the overflowing operation again. - id, _ := getRelationKey(source, target, IntersectionStateNone, relation == c.identityRelation, false /*ignoreConstraints*/) - relation.set(id, RelationComparisonResultFailed|RelationComparisonResultComplexityOverflow) if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "checkTypeRelatedTo_DepthLimit", map[string]any{"sourceId": source.id, "targetId": target.id, "depth": len(r.sourceStack), "targetDepth": len(r.targetStack)}) } - if errorNode == nil { - errorNode = c.currentNode + message, sourceString, targetString := diagnostics.Excessive_complexity_comparing_types_0_and_1, c.TypeToString(source), c.TypeToString(target) + switch { + case errorNode != nil: + c.reportDiagnostic(NewDiagnosticForNode(errorNode, message, sourceString, targetString), diagnosticOutput) + case diagnosticOutput != nil: + c.reportDiagnostic(NewDiagnosticForNode(c.currentNode, message, sourceString, targetString), diagnosticOutput) + default: + c.errorAtCurrentNode(message, sourceString, targetString) } - c.reportDiagnostic(NewDiagnosticForNode(errorNode, diagnostics.Excessive_complexity_comparing_types_0_and_1, c.TypeToString(source), c.TypeToString(target)), diagnosticOutput) } else if r.errorChain != nil { // Check if we should issue an extra diagnostic to produce a quickfix for a slightly incorrect import statement if headMessage != nil && errorNode != nil && result == TernaryFalse && source.symbol != nil && c.exportTypeLinks.Has(source.symbol) { @@ -766,7 +834,7 @@ func isExcessPropertyCheckTarget(t *Type) bool { // structurally equal to at least maxDepth levels, but unequal at some level beyond that. func (c *Checker) isDeeplyNestedType(t *Type, stack []*Type, maxDepth int) bool { if len(stack) >= maxDepth { - target := getRecursionIdentityTarget(t) + target := c.getRecursionIdentityTarget(t) if target.flags&TypeFlagsIntersection != 0 { for _, t := range target.Types() { if c.isDeeplyNestedType(t, stack, maxDepth) { @@ -774,20 +842,22 @@ func (c *Checker) isDeeplyNestedType(t *Type, stack []*Type, maxDepth int) bool } } } else { - identity := getRecursionIdentityFromTarget(target) + identity := c.getRecursionIdentityFromTarget(target) count := 0 - lastTypeId := TypeId(0) + lastGeneration := 0 for _, t := range stack { - if hasMatchingRecursionIdentity(t, identity) { - // We only count occurrences with a higher type id than the previous occurrence, since higher - // type ids are an indicator of newer instantiations caused by recursion. - if t.id >= lastTypeId { + if c.hasMatchingRecursionIdentity(t, identity) { + // We only count occurrences of a generation at least that of the previous occurrence, since + // newer instantiations caused by recursion are built from the previous ones, whereas nested + // type arguments are older than the types they are arguments of. + generation := c.typeGeneration(t) + if generation >= lastGeneration { count++ if count >= maxDepth { return true } } - lastTypeId = t.id + lastGeneration = generation } } } @@ -795,21 +865,119 @@ func (c *Checker) isDeeplyNestedType(t *Type, stack []*Type, maxDepth int) bool return false } -func hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { - target := getRecursionIdentityTarget(t) +const ( + maxTypeGeneration = 1<<16 - 3 + typeGenerationInProgress = 1<<16 - 1 +) + +// typeGeneration returns one more than the highest generation of the types t +// was instantiated from, or zero if it was not instantiated from any. A type is +// created after the types it is instantiated from, so this orders types by +// creation where the order follows from their structure, and unlike type ids +// does not depend on the order in which unrelated types were created. +func (c *Checker) typeGeneration(t *Type) int { + debug.Assert(t.generation != typeGenerationInProgress, "types are only built from existing types") + if t.generation != 0 { + return int(t.generation) - 1 + } + t.generation = typeGenerationInProgress + generation := 0 + switch { + case t.flags&TypeFlagsObject != 0: + if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == nil { + generation = c.typesGeneration(t.AsTypeReference().typeArgumentsOfCreation()) + } else if m := t.AsObjectType().mapper; m != nil { + generation = c.mapperGeneration(m) + } else if t.symbol != nil && t.symbol.Flags()&ast.SymbolFlagsObjectLiteral != 0 { + // Object literals are built from the types of their properties, + // except for those resolved lazily, such as accessors. + for prop := range t.AsStructuredType().members.Values() { + if prop.Flags()&ast.SymbolFlagsTransient == 0 || prop.CheckFlags()&(ast.CheckFlagsInstantiated|ast.CheckFlagsMapped|ast.CheckFlagsReverseMapped|ast.CheckFlagsDeferredType) != 0 { + continue + } + if propType := c.peekTypeOfObjectLiteralMember(prop); propType != nil { + generation = max(generation, c.typeGeneration(propType)+1) + } + } + } + case t.flags&TypeFlagsConditional != 0: + if m := t.AsConditionalType().mapper; m != nil { + generation = c.mapperGeneration(m) + } + case t.flags&TypeFlagsIndexedAccess != 0: + d := t.AsIndexedAccessType() + generation = max(c.typeGeneration(d.objectType), c.typeGeneration(d.indexType)) + 1 + case t.flags&TypeFlagsUnionOrIntersection != 0, t.flags&TypeFlagsTemplateLiteral != 0: + generation = c.typesGeneration(t.Types()) + case t.flags&TypeFlagsIndex != 0, t.flags&TypeFlagsStringMapping != 0: + generation = c.typeGeneration(t.Target()) + 1 + case t.flags&TypeFlagsSubstitution != 0: + d := t.AsSubstitutionType() + generation = max(c.typeGeneration(d.baseType), c.typeGeneration(d.constraint)) + 1 + } + generation = min(generation, maxTypeGeneration) + t.generation = uint16(generation + 1) + return generation +} + +func (c *Checker) typesGeneration(types []*Type) int { + generation := -1 + for _, t := range types { + generation = max(generation, c.typeGeneration(t)) + } + return generation + 1 +} + +// mapperGeneration returns one more than the highest generation of the types +// that m maps to, as far as they are known without computing them. +func (c *Checker) mapperGeneration(m *TypeMapper) int { + switch m.kind { + case TypeMapperKindSimple: + return c.typeGeneration(castTypeMapper[SimpleTypeMapper](m, TypeMapperKindSimple).target) + 1 + case TypeMapperKindArray: + return c.typesGeneration(castTypeMapper[ArrayTypeMapper](m, TypeMapperKindArray).targets) + case TypeMapperKindArrayToSingle: + return c.typeGeneration(castTypeMapper[ArrayToSingleTypeMapper](m, TypeMapperKindArrayToSingle).target) + 1 + case TypeMapperKindMerged: + d := castTypeMapper[MergedTypeMapper](m, TypeMapperKindMerged) + return max(c.mapperGeneration(d.m1), c.mapperGeneration(d.m2)) + case TypeMapperKindComposite: + d := castTypeMapper[CompositeTypeMapper](m, TypeMapperKindComposite) + return max(c.mapperGeneration(d.m1), c.mapperGeneration(d.m2)) + } + return 0 +} + +// deeplyNestedStart returns the highest index in stack from which t is still +// deeply nested, or -1 if it is not deeply nested. Comparisons starting at or +// below that index would be truncated the same way. +func (c *Checker) deeplyNestedStart(t *Type, stack []*Type, maxDepth int) int { + if !c.isDeeplyNestedType(t, stack, maxDepth) { + return -1 + } + for k := len(stack) - maxDepth; k > 0; k-- { + if c.isDeeplyNestedType(t, stack[k:], maxDepth) { + return k + } + } + return 0 +} + +func (c *Checker) hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { + target := c.getRecursionIdentityTarget(t) if target.flags&TypeFlagsIntersection != 0 { for _, t := range target.Types() { - if hasMatchingRecursionIdentity(t, identity) { + if c.hasMatchingRecursionIdentity(t, identity) { return true } } return false } - return getRecursionIdentityFromTarget(target) == identity + return c.getRecursionIdentityFromTarget(target) == identity } -func getRecursionIdentity(t *Type) RecursionId { - return getRecursionIdentityFromTarget(getRecursionIdentityTarget(t)) +func (c *Checker) getRecursionIdentity(t *Type) RecursionId { + return c.getRecursionIdentityFromTarget(c.getRecursionIdentityTarget(t)) } // Get the recursion identity target type from a type. Recursively (a) obtain the target object type of an @@ -818,15 +986,15 @@ func getRecursionIdentity(t *Type) RecursionId { // to explicitly written object literals. For example in `Mapped<{ x: Mapped<{ x: Mapped<{ x: string }>}>}>`, // each of the mapped type applications will have a unique recursion identity (that of their target object type // literal) and thus avoid appearing deeply nested. -func getRecursionIdentityTarget(t *Type) *Type { +func (c *Checker) getRecursionIdentityTarget(t *Type) *Type { if t.flags&TypeFlagsIndexedAccess != 0 { - return getRecursionIdentityTarget(t.AsIndexedAccessType().objectType) + return c.getRecursionIdentityTarget(t.AsIndexedAccessType().objectType) } if t.objectFlags&ObjectFlagsInstantiatedMapped == ObjectFlagsInstantiatedMapped { - target := t.checker.getModifiersTypeFromMappedType(t) + target := c.getModifiersTypeFromMappedType(t) if target != nil && (target.symbol != nil || target.flags&TypeFlagsIntersection != 0 && core.Some(target.Types(), func(t *Type) bool { return t.symbol != nil })) { - return getRecursionIdentityTarget(target) + return c.getRecursionIdentityTarget(target) } } return t @@ -838,7 +1006,7 @@ func getRecursionIdentityTarget(t *Type) *Type { // instantiations of that type have the same recursion identity. The default recursion identity is the object // identity of the type, meaning that every type is unique. Generally, types with constituents that could circularly // reference the type have a recursion identity that differs from the object identity. -func getRecursionIdentityFromTarget(t *Type) RecursionId { +func (c *Checker) getRecursionIdentityFromTarget(t *Type) RecursionId { // Object and array literals are known not to contain recursive references and don't need a recursion identity. if t.flags&TypeFlagsObject != 0 && !isObjectOrArrayLiteralType(t) { if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node != nil { @@ -847,14 +1015,18 @@ func getRecursionIdentityFromTarget(t *Type) RecursionId { // unique AST node. return asRecursionId(t.AsTypeReference().node) } - if t.symbol != nil && !(t.objectFlags&ObjectFlagsAnonymous != 0 && t.symbol.Flags()&ast.SymbolFlagsClass != 0) && t.objectFlags&ObjectFlagsFromTypeNode == 0 { + // A type reference whose type arguments were not themselves + // instantiated, such as one written out in a type node, cannot be the + // source of generative recursion, so it is tracked by itself. Type + // references are interned, so this depends on the type arguments + // rather than on how the reference was first created. + generative := t.objectFlags&ObjectFlagsReference == 0 || c.typeGeneration(t) > 1 + if t.symbol != nil && !(t.objectFlags&ObjectFlagsAnonymous != 0 && t.symbol.Flags()&ast.SymbolFlagsClass != 0) && generative { // We track object types that have a symbol by that symbol (representing the origin of the type), but - // exclude the static sides of classes (since they share their symbols with the instance sides) and type - // references that originate in resolution of AST type nodes (since such type nodes cannot be the source - // of generative recursion without first being instantiated). + // exclude the static sides of classes (since they share their symbols with the instance sides). return asRecursionId(t.symbol) } - if isTupleType(t) && t.objectFlags&ObjectFlagsFromTypeNode == 0 { + if isTupleType(t) && generative { return asRecursionId(t.Target()) } } @@ -1084,18 +1256,35 @@ func (c *Checker) isDiscriminantProperty(t *Type, name string) bool { if t != nil && t.flags&TypeFlagsUnion != 0 { prop := c.getUnionOrIntersectionProperty(t, name, false /*skipObjectFunctionPropertyAugment*/) if prop != nil && prop.CheckFlags()&ast.CheckFlagsSyntheticProperty != 0 { - if prop.CheckFlags()&ast.CheckFlagsIsDiscriminantComputed == 0 { - prop.SetCheckFlags(prop.CheckFlags() | ast.CheckFlagsIsDiscriminantComputed) - if prop.CheckFlags()&ast.CheckFlagsNonUniformAndLiteral == ast.CheckFlagsNonUniformAndLiteral && !c.isGenericType(c.getTypeOfSymbol(prop)) { - prop.SetCheckFlags(prop.CheckFlags() | ast.CheckFlagsIsDiscriminant) - } + key := memoKeyOf(prop, memoDiscriminant) + if prop.CheckFlags()&ast.CheckFlagsIsDiscriminantComputed != 0 { + c.observeFlagMemo(key) + return prop.CheckFlags()&ast.CheckFlagsIsDiscriminant != 0 } + c.beginMemo(key) + c.setDiscriminantFlags(prop, ast.CheckFlagsIsDiscriminantComputed) + if prop.CheckFlags()&ast.CheckFlagsNonUniformAndLiteral == ast.CheckFlagsNonUniformAndLiteral && !c.isGenericType(c.getTypeOfSymbol(prop)) { + c.setDiscriminantFlags(prop, ast.CheckFlagsIsDiscriminantComputed|ast.CheckFlagsIsDiscriminant) + } + c.endMemo() return prop.CheckFlags()&ast.CheckFlagsIsDiscriminant != 0 } } return false } +// setDiscriminantFlags caches whether the synthetic property prop is a +// discriminant, a flag memo. +func (c *Checker) setDiscriminantFlags(prop *ast.Symbol, flags ast.CheckFlags) { + const mask = ast.CheckFlagsIsDiscriminantComputed | ast.CheckFlagsIsDiscriminant + if c.logResults() { + old := prop.CheckFlags() & mask + c.logMemoDiscard(nil, memoKeyOf(prop, memoDiscriminant), func() { prop.SetCheckFlags(prop.CheckFlags()&^mask | old) }) + } + prop.SetCheckFlags(prop.CheckFlags()&^mask | flags) + c.setFlagMemo(memoKeyOf(prop, memoDiscriminant)) +} + func (c *Checker) getMatchingUnionConstituentForType(unionType *Type, t *Type) *Type { keyPropertyName := c.getKeyPropertyName(unionType) if keyPropertyName == "" { @@ -1113,13 +1302,15 @@ func (c *Checker) getMatchingUnionConstituentForType(unionType *Type, t *Type) * // an empty string if no such discriminant property exists. func (c *Checker) getKeyPropertyName(t *Type) string { u := t.AsUnionType() - if u.keyPropertyName == "" { - u.keyPropertyName, u.constituentMap = c.computeKeyPropertyNameAndMap(t) - } - if u.keyPropertyName == ast.InternalSymbolNameMissing { + name := c.memoCompute(&u.keyPropertyName, func() string { + var name string + name, u.constituentMap = c.computeKeyPropertyNameAndMap(t) + return name + }) + if name == ast.InternalSymbolNameMissing { return "" } - return u.keyPropertyName + return name } // Given a union type for which getKeyPropertyName returned a non-empty string, return the constituent @@ -1326,7 +1517,7 @@ func (c *Checker) getVariances(t *Type) []VarianceFlags { } func (c *Checker) getAliasVariances(symbol *ast.Symbol) []VarianceFlags { - return c.getVariancesWorker(symbol, c.typeAliasLinks.Get(symbol).typeParameters) + return c.getVariancesWorker(symbol, c.getTypeParametersOfTypeAlias(symbol)) } // Return an array containing the variance of each type parameter. The variance is effectively @@ -1336,114 +1527,220 @@ func (c *Checker) getAliasVariances(symbol *ast.Symbol) []VarianceFlags { // returns an empty slice when invoked recursively for the given generic type. func (c *Checker) getVariancesWorker(symbol *ast.Symbol, typeParameters []*Type) []VarianceFlags { links := c.varianceLinks.Get(symbol) - if links.variances == nil { - var traceArgs map[string]any - if tr := c.tracer; tr != nil { - traceArgs = map[string]any{"arity": len(typeParameters), "id": c.getDeclaredTypeOfSymbol(symbol).id} - popFn := tr.Push(tracing.PhaseCheckTypes, "getVariancesWorker", traceArgs, true) - defer func() { - formatted := make([]string, len(links.variances)) - for i, v := range links.variances { - formatted[i] = v.String() - } - traceArgs["variances"] = formatted - popFn() - }() - } - stackIndex := c.getVarianceStackIndex(symbol) - if stackIndex < 0 { - saveResolutionStart := c.resolutionStart - if len(c.varianceStack) == 0 { - c.resolutionStart = len(c.typeResolutions) - } - c.varianceStack = append(c.varianceStack, VarianceStackEntry{symbol, typeParameters}) - variances := make([]VarianceFlags, len(typeParameters)) - for i, tp := range typeParameters { - modifiers := c.getTypeParameterModifiers(tp) - var variance VarianceFlags - switch { - case modifiers&ast.ModifierFlagsOut != 0: - if modifiers&ast.ModifierFlagsIn != 0 { - variance = VarianceFlagsInvariant - } else { - variance = VarianceFlagsCovariant - } - case modifiers&ast.ModifierFlagsIn != 0: - variance = VarianceFlagsContravariant - default: - saveReliabilityFlags := c.reliabilityFlags - c.reliabilityFlags = 0 - // We first compare instantiations where the type parameter is replaced with - // marker types that have a known subtype relationship. From this we can infer - // invariance, covariance, contravariance or bivariance. - typeWithSuper := c.createMarkerType(symbol, tp, c.markerSuperType) - typeWithSub := c.createMarkerType(symbol, tp, c.markerSubType) - variance = core.IfElse(c.isTypeAssignableTo(typeWithSub, typeWithSuper), VarianceFlagsCovariant, 0) | - core.IfElse(c.isTypeAssignableTo(typeWithSuper, typeWithSub), VarianceFlagsContravariant, 0) - // If the instantiations appear to be related bivariantly it may be because the - // type parameter is independent (i.e. it isn't witnessed anywhere in the generic - // type). To determine this we compare instantiations where the type parameter is - // replaced with marker types that are known to be unrelated. - if variance == VarianceFlagsBivariant && c.isTypeAssignableTo(c.createMarkerType(symbol, tp, c.markerOtherType), typeWithSuper) { - variance = VarianceFlagsIndependent - } - if c.reliabilityFlags&RelationComparisonResultReportsUnmeasurable != 0 { - variance |= VarianceFlagsUnmeasurable - } - if c.reliabilityFlags&RelationComparisonResultReportsUnreliable != 0 { - variance |= VarianceFlagsUnreliable - } - c.reliabilityFlags = saveReliabilityFlags - } - // If variance computation was restarted due to a circularity we may have already - // computed variances for this generic type. If so, we exit early. - if len(links.variances) != 0 { - break - } - variances[i] = variance - } - // Store the results unless a restarted computation has already stored them. - if len(links.variances) == 0 { - links.variances = variances - } - c.varianceStack = c.varianceStack[:len(c.varianceStack)-1] - if len(c.varianceStack) == 0 { - c.resolutionStart = saveResolutionStart - } - } else { - // We've detected a circularity. Since we may compute different variances depending on where - // we enter a circularity, we find the generic type with the "smallest" symbol in the circular - // region of the variance stack and restart the computation from there if necessary. This - // ensures stable results for circular generic types. - minIndex := stackIndex - for i := stackIndex + 1; i < len(c.varianceStack); i++ { - if c.compareSymbols(c.varianceStack[i].symbol, c.varianceStack[minIndex].symbol) < 0 { - minIndex = i - } - } - if minIndex > stackIndex { - saveVarianceStack := c.varianceStack - c.varianceStack = nil - c.getVariancesWorker(saveVarianceStack[minIndex].symbol, saveVarianceStack[minIndex].typeParameters) - c.varianceStack = saveVarianceStack + if variances := links.variances.cached(c); variances != nil { + return variances + } + if stackIndex := c.getVarianceStackIndex(symbol); stackIndex >= 0 { + return c.getRecursiveVariances(stackIndex) + } + var traceArgs map[string]any + if tr := c.tracer; tr != nil { + traceArgs = map[string]any{"arity": len(typeParameters), "id": c.getDeclaredTypeOfSymbol(symbol).id} + popFn := tr.Push(tracing.PhaseCheckTypes, "getVariancesWorker", traceArgs, true) + defer func() { + variances := links.variances.cached(c) + formatted := make([]string, len(variances)) + for i, v := range variances { + formatted[i] = v.String() + } + traceArgs["variances"] = formatted + popFn() + }() + } + links.variances.begin(c) + saveResolutionStart := c.resolutionStart + if len(c.varianceStack) == 0 { + c.resolutionStart = len(c.resolutions) + } + index := len(c.varianceStack) + c.varianceStack = append(c.varianceStack, VarianceStackEntry{symbol: symbol, resolution: len(c.resolutions), low: index, min: symbol, minTypeParameters: typeParameters, discardPoint: c.discardPoint(), provisionalStart: len(c.varianceProvisional)}) + c.beginTypeResolution(symbol, TypeSystemPropertyNameVariances, &links.variances.memoHeader) + variances := c.measureVariances(symbol, typeParameters, links) + e := c.varianceStack[index] + if index == 0 { + // A superseded measurement found a smaller type in its circularity, + // from which it is measured again below. + debug.Assert(!c.varianceSuperseded || e.min != symbol && !c.isYieldingTo(e.min, TypeSystemPropertyNameVariances), "superseded variance measurement not measured again") + c.varianceSuperseded = false + } + if e.low == index && e.min != symbol && !c.isYieldingTo(e.min, TypeSystemPropertyNameVariances) { + // The measurement entered a circularity, of which this type is the + // first entered, at a type other than the canonical entry. What it + // measured depends on where the circularity was entered, so it is + // discarded, and the circularity measured again from the canonical + // entry, as if that type had been measured first, with nothing in + // progress visible. That measures this type as it reaches it. + c.discardVariancesSince(e) + saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor, saveHeldFloor := c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor, c.heldEffectsFloor + c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor, c.heldEffectsFloor = nil, 0, nil, len(c.discardLog), len(c.heldEffects) + c.beginCycleYield(e.min, TypeSystemPropertyNameVariances, -1, len(c.resolutions)) + c.getVariancesWorker(e.min, e.minTypeParameters) + c.endCycleYield() + c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor, c.heldEffectsFloor = saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor, saveHeldFloor + variances = links.variances.cached(c) + if len(variances) == 0 { + c.varianceStack[index].remeasuring = true + variances = c.measureVariances(symbol, typeParameters, links) + } + } else if restarted := links.variances.cached(c); len(restarted) != 0 { + // A measurement from the canonical entry of a circularity measured + // this type while its own measurement was in progress, hidden. + variances = restarted + } + links.variances.set(c, variances) + if c.varianceCycleRoot == index+1 { + c.varianceCycleRoot = 0 + c.trimDiscardLog() + c.resumeChecking() + } + c.varianceStack = c.varianceStack[:index] + if index != 0 && e.low < index { + // This type is in a circularity with the measurement that reached it, + // so its variances depend on those of a measurement in progress, and + // are as much a guess as those until it finishes. + c.varianceProvisional = append(c.varianceProvisional, symbol) + parent := &c.varianceStack[index-1] + parent.low = min(parent.low, e.low) + if c.compareSymbols(e.min, parent.min) < 0 { + parent.min, parent.minTypeParameters = e.min, e.minTypeParameters + } + } else { + clear(c.varianceProvisional[e.provisionalStart:]) + c.varianceProvisional = c.varianceProvisional[:e.provisionalStart] + } + c.popTypeResolution() + if len(c.varianceStack) == 0 { + c.resolutionStart = saveResolutionStart + } + c.endMemo() + return variances +} + +// getRecursiveVariances handles a measurement needing the variances of the type at the given +// index of the variance stack, whose measurement is in progress. Occurrences of type parameters +// nested in such recursive references are not measured: the variances are an empty slice, which +// comparisons treat as unknown. Since the variances measured then depend on where the +// circularity was entered, each circularity (a strongly connected component of types whose +// measurements need each other's variances) is measured from a canonical entry, the type with +// the "smallest" symbol, as if that type had been measured first: the measurement of the type +// at which it was entered finds the canonical entry once it finishes (see getVariancesWorker). +func (c *Checker) getRecursiveVariances(stackIndex int) []VarianceFlags { + top := &c.varianceStack[len(c.varianceStack)-1] + top.low = min(top.low, stackIndex) + // The variances are incomplete. Only comparisons and inferences read + // variances, and a comparison observing them is not cached. What else + // is computed from them is kept if the measurement is not discarded: + // the outermost measurement hides what is below it, so what is computed + // inside it is the same whatever led to it, and computing any of it + // first from scratch reaches the measurement and computes it again + // inside, the same way. What is cached from now on until the + // measurement re-entered finishes is logged, so that it can be discarded + // if the measurement is, and a check holds the effects it applies until + // then (see holdEffect). + if c.varianceCycleRoot == 0 { + c.varianceCycleRoot = stackIndex + 1 + } else { + c.varianceCycleRoot = min(c.varianceCycleRoot, stackIndex+1) + } + bottom := &c.varianceStack[0] + c.reliabilityFlags |= RelationComparisonResultReportsIncomplete + if stackIndex == 0 && !c.varianceSuperseded && !c.varianceStack[0].remeasuring { + // The circularity includes the measurement at the bottom of the stack, + // so that is where it was entered. If it has a smaller type, what the + // measurement measures is discarded once it finishes, so it stops + // measuring now (see Relater.recursiveTypeRelatedTo). + for _, f := range c.varianceStack[1:] { + if c.compareSymbols(f.min, bottom.symbol) < 0 && !c.isYieldingTo(f.min, TypeSystemPropertyNameVariances) { + c.varianceSuperseded = true + break } - // Store an empty slice to mark that we can't compute variances for this type. We treat type - // parameters as co-variant in this case. - if len(links.variances) == 0 { - links.variances = []VarianceFlags{} + } + } + return []VarianceFlags{} +} + +// discardVariancesSince discards the results cached since e began, and all +// the effects the measurement recorded. +func (c *Checker) discardVariancesSince(e VarianceStackEntry) { + clear(c.varianceProvisional[e.provisionalStart:]) + c.varianceProvisional = c.varianceProvisional[:e.provisionalStart] + c.discardTo(e.discardPoint) + if f := c.resolutions[e.resolution-1].effects; f != nil { + f.truncate(0, 0) + } +} + +func (c *Checker) measureVariances(symbol *ast.Symbol, typeParameters []*Type, links *VarianceLinks) []VarianceFlags { + variances := make([]VarianceFlags, len(typeParameters)) + for i, tp := range typeParameters { + modifiers := c.getTypeParameterModifiers(tp) + var variance VarianceFlags + switch { + case modifiers&ast.ModifierFlagsOut != 0: + if modifiers&ast.ModifierFlagsIn != 0 { + variance = VarianceFlagsInvariant + } else { + variance = VarianceFlagsCovariant } + case modifiers&ast.ModifierFlagsIn != 0: + variance = VarianceFlagsContravariant + default: + saveReliabilityFlags := c.reliabilityFlags + c.reliabilityFlags = 0 + // We first compare instantiations where the type parameter is replaced with + // marker types that have a known subtype relationship. From this we can infer + // invariance, covariance, contravariance or bivariance. + typeWithSuper := c.createMarkerType(symbol, tp, c.markerSuperType) + typeWithSub := c.createMarkerType(symbol, tp, c.markerSubType) + variance = core.IfElse(c.isTypeAssignableTo(typeWithSub, typeWithSuper), VarianceFlagsCovariant, 0) | + core.IfElse(c.isTypeAssignableTo(typeWithSuper, typeWithSub), VarianceFlagsContravariant, 0) + // If the instantiations appear to be related bivariantly it may be because the + // type parameter is independent (i.e. it isn't witnessed anywhere in the generic + // type). To determine this we compare instantiations where the type parameter is + // replaced with marker types that are known to be unrelated. + if variance == VarianceFlagsBivariant && c.isTypeAssignableTo(c.createMarkerType(symbol, tp, c.markerOtherType), typeWithSuper) { + variance = VarianceFlagsIndependent + } + if c.reliabilityFlags&RelationComparisonResultReportsUnmeasurable != 0 { + variance |= VarianceFlagsUnmeasurable + } + if c.reliabilityFlags&RelationComparisonResultReportsUnreliable != 0 { + variance |= VarianceFlagsUnreliable + } + c.reliabilityFlags = saveReliabilityFlags + } + // If variance computation was restarted due to a circularity we may have already + // computed variances for this generic type. If so, we exit early. + if len(links.variances.inProgress(c)) != 0 { + break } + variances[i] = variance } - return links.variances + return variances +} + +// isGuessedVariance reports whether the variances of symbol are a guess: +// those of a measurement in progress, or measured in a circularity with one. +func (c *Checker) isGuessedVariance(symbol *ast.Symbol) bool { + return c.getVarianceStackIndex(symbol) >= 0 || slices.Contains(c.varianceProvisional, symbol) } +// getVarianceStackIndex returns the index in the variance stack of the +// measurement of the variances of symbol in progress, or -1. A measurement +// hidden by a cycle yield is not in progress. func (c *Checker) getVarianceStackIndex(symbol *ast.Symbol) int { - for i, entry := range c.varianceStack { - if entry.symbol == symbol { - return i - } + if len(c.varianceStack) == 0 { + return -1 + } + r := c.resolvingIndex(c.varianceLinks.Get(symbol).variances.key()) + if r == 0 { + return -1 } - return -1 + i, found := slices.BinarySearchFunc(c.varianceStack, r, func(e VarianceStackEntry, r int) int { return e.resolution - r }) + if !found { + return -1 + } + return i } func (c *Checker) createMarkerType(symbol *ast.Symbol, source *Type, target *Type) *Type { @@ -1454,16 +1751,67 @@ func (c *Checker) createMarkerType(symbol *ast.Symbol, source *Type, target *Typ } var result *Type if symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 { - result = c.getTypeAliasInstantiation(symbol, c.instantiateTypes(c.typeAliasLinks.Get(symbol).typeParameters, mapper), nil) + result = c.getTypeAliasInstantiation(symbol, c.instantiateTypes(c.getTypeParametersOfTypeAlias(symbol), mapper), nil) } else { result = c.createTypeReference(t, c.instantiateTypes(t.AsInterfaceType().TypeParameters(), mapper)) } - c.markerTypes.Add(result) return result } +// isMarkerType reports whether t is a marker type of the innermost variance +// computation or variance annotation check in progress: an instantiation of +// the generic type or type alias being measured with one of its type +// parameters replaced by a variance marker. Instantiations of other types with +// markers, such as those nested in the type being measured, are not marker +// types, whether or not their own variances have been measured before. Nor +// are those of measurements further down the variance stack: a reference to +// them must get their variances, so that the circularity is found and +// measured from its canonical entry (see getRecursiveVariances). func (c *Checker) isMarkerType(t *Type) bool { - return c.markerTypes.Has(t) + if len(c.varianceStack) == 0 && c.varianceTypeParameter == nil { + return false + } + if t.alias != nil && t.alias.symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 && + c.isMarkerInstantiation(t.alias.symbol, c.typeAliasLinks.Get(t.alias.symbol).typeParameters, t.alias.typeArguments) { + return true + } + if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == nil { + target := t.Target() + if target != nil && target != t && target.objectFlags&ObjectFlagsClassOrInterface != 0 { + return c.isMarkerInstantiation(target.symbol, target.AsInterfaceType().TypeParameters(), t.AsTypeReference().typeArgumentsOfCreation()) + } + } + return false +} + +func (c *Checker) isMarkerInstantiation(symbol *ast.Symbol, typeParameters []*Type, typeArguments []*Type) bool { + if len(typeParameters) == 0 || len(typeParameters) != len(typeArguments) { + return false + } + replaced := -1 + for i, tp := range typeParameters { + if typeArguments[i] == tp { + continue + } + if replaced >= 0 || !c.isVarianceMarker(typeArguments[i]) { + return false + } + replaced = i + } + if replaced < 0 { + return false + } + switch typeArguments[replaced] { + case c.markerSuperTypeForCheck, c.markerSubTypeForCheck: + return typeParameters[replaced] == c.varianceTypeParameter + default: + return len(c.varianceStack) != 0 && c.varianceStack[len(c.varianceStack)-1].symbol == symbol + } +} + +func (c *Checker) isVarianceMarker(t *Type) bool { + return t == c.markerSuperType || t == c.markerSubType || t == c.markerOtherType || + t == c.markerSuperTypeForCheck || t == c.markerSubTypeForCheck } func (c *Checker) getTypeParameterModifiers(tp *Type) ast.ModifierFlags { @@ -1742,9 +2090,23 @@ func (c *Checker) getMinArgumentCount(signature *Signature) int { } func (c *Checker) getMinArgumentCountEx(signature *Signature, flags MinArgumentCountFlags) int { + voidIsNonOptional := flags & MinArgumentCountFlagsVoidIsNonOptional + if voidIsNonOptional != 0 { + return c.getMinArgumentCountUncached(signature, flags) + } + if count := signature.resolvedMinArgumentCount.cached(c); count != -1 { + return int(count) + } + signature.resolvedMinArgumentCount.begin(c) + result := c.getMinArgumentCountUncached(signature, flags) + c.endMemo() + return result +} + +func (c *Checker) getMinArgumentCountUncached(signature *Signature, flags MinArgumentCountFlags) int { strongArityForUntypedJS := flags & MinArgumentCountFlagsStrongArityForUntypedJS voidIsNonOptional := flags & MinArgumentCountFlagsVoidIsNonOptional - if voidIsNonOptional != 0 || signature.resolvedMinArgumentCount == -1 { + { minArgumentCount := -1 if signatureHasRestParameter(signature) { restType := c.getTypeOfSymbol(signature.parameters[len(signature.parameters)-1]) @@ -1777,9 +2139,9 @@ func (c *Checker) getMinArgumentCountEx(signature *Signature, flags MinArgumentC } minArgumentCount = i } - signature.resolvedMinArgumentCount = int32(minArgumentCount) + signature.resolvedMinArgumentCount.set(c, int32(minArgumentCount)) + return minArgumentCount } - return int(signature.resolvedMinArgumentCount) } func (c *Checker) hasEffectiveRestParameter(signature *Signature) bool { @@ -2050,6 +2412,22 @@ func (c *Checker) getTupleElementLabelFromBindingElement(node *ast.Node, index i } func (c *Checker) getTypePredicateOfSignature(sig *Signature) *TypePredicate { + key := memoKeyOf(sig, memoTypePredicate) + if sig.getResolvedTypePredicate(c) != nil { + c.observeFlagMemo(key) + } else { + c.beginMemo(key) + c.resolveTypePredicateOfSignature(sig) + c.endMemo() + } + predicate := sig.getResolvedTypePredicate(c) + if predicate == c.noTypePredicate { + return nil + } + return predicate +} + +func (c *Checker) resolveTypePredicateOfSignature(sig *Signature) { if sig.getResolvedTypePredicate(c) == nil { switch { case sig.target != nil: @@ -2067,7 +2445,7 @@ func (c *Checker) getTypePredicateOfSignature(sig *Signature) *TypePredicate { if ast.IsTypePredicateNode(typeNode) { sig.setResolvedTypePredicate(c, c.createTypePredicateFromTypePredicateNode(typeNode, sig)) } - case ast.IsFunctionLikeDeclaration(sig.declaration) && (sig.resolvedReturnType == nil || sig.resolvedReturnType.flags&TypeFlagsBoolean != 0) && c.getParameterCount(sig) > 0: + case ast.IsFunctionLikeDeclaration(sig.declaration) && c.getParameterCount(sig) > 0: sig.setResolvedTypePredicate(c, c.noTypePredicate) // avoid infinite loop sig.setResolvedTypePredicate(c, c.getTypePredicateFromBody(sig.declaration)) } @@ -2077,11 +2455,6 @@ func (c *Checker) getTypePredicateOfSignature(sig *Signature) *TypePredicate { sig.setResolvedTypePredicate(c, c.noTypePredicate) } } - predicate := sig.getResolvedTypePredicate(c) - if predicate == c.noTypePredicate { - return nil - } - return predicate } func (c *Checker) getUnionOrIntersectionTypePredicate(signatures []*Signature, isUnion bool) *TypePredicate { @@ -2150,7 +2523,15 @@ func (c *Checker) isResolvingReturnTypeOfSignature(signature *Signature) bool { if signature.getComposite() != nil && core.Some(signature.getComposite().signatures, c.isResolvingReturnTypeOfSignature) { return true } - return signature.resolvedReturnType == nil && c.findResolutionCycleStartIndex(signature, TypeSystemPropertyNameResolvedReturnType) >= 0 + start := c.findResolutionCycleStartIndex(signature, TypeSystemPropertyNameResolvedReturnType) + if start < 0 { + return false + } + c.markTypeResolutionCircular(start) + // Computed from the first member of the cycle, the return type may be + // available after all. + c.yieldObservedCycle(start) + return signature.resolvedReturnType.inProgress(c) == nil } func (c *Checker) findMatchingSignatures(signatureLists [][]*Signature, signature *Signature, listIndex int) []*Signature { @@ -2582,22 +2963,89 @@ type ErrorChain struct { } type Relater struct { - c *Checker - relation *Relation - errorNode *ast.Node - errorChain *ErrorChain - relatedInfo []*ast.Diagnostic - maybeKeys []CacheHashKey - maybeKeysSet collections.Set[CacheHashKey] - sourceStack []*Type - targetStack []*Type - maybeCount int - sourceDepth int - targetDepth int + c *Checker + relation *Relation + errorNode *ast.Node + errorChain *ErrorChain + relatedInfo []*ast.Diagnostic + // maybeKeys are the comparisons in progress, followed by completed ones + // that hold assuming comparisons still in progress. maybeKeysSet indexes + // them by key. + maybeKeys []maybeKey + maybeKeysSet map[CacheHashKey]int + // The outermost comparison and its relation key. + topSource, topTarget *Type + topKey CacheHashKey + topConstrained bool + topEntry RelationComparisonResult // The result cached for topKey when the comparison began + topEntryValid bool // Whether topEntry is unused, and so still the cached result + topHasKey bool // Whether topKey and topConstrained are known + topEntryRead bool // Whether the caller read topEntry, when the relation had topEntryWrites writes + topEntryWrites uint32 + topBegun bool // Whether the comparison began its computation; see beginTop + sourceStack []*Type + targetStack []*Type + // sourceDepths and targetDepths are the depths of the comparisons that + // pushed each entry of sourceStack and targetStack. + sourceDepths []int + targetDepths []int + // depth is the number of comparisons in progress. + depth int + // low is the lowest depth that the result of the innermost comparison in + // progress depends on, through assumptions or truncation. Results that + // depend on no comparison below their own are the same from scratch. + low int + // truncated is set if that result depends on a truncation that would not + // happen from scratch. + truncated bool expandingFlags ExpandingFlags - overflow bool - relationCount int - next *Relater + // expandingSourceDepth and expandingTargetDepth are the highest depths + // from which the expanding flags would still be set. + expandingSourceDepth int + expandingTargetDepth int + overflow bool + relationCount int + next *Relater +} + +type maybeKey struct { + key CacheHashKey + // low is the lowest depth that the comparison depends on, which is its + // own while it is in progress. + low int + result Ternary + truncated bool +} + +// beginTop makes the outermost comparison a computation of its own, so that +// reusing any result it caches accounts for the effects of the whole +// comparison. Errors are reported after it, since they belong to the caller +// rather than the result. Only recursiveTypeRelatedTo caches results, so the +// comparison begins on its first call there, and most comparisons, which +// finish before, need neither the computation nor the relation key. What the +// comparison did before then cannot affect a result it caches other than +// through the types it compares. beginTop returns false if the comparison +// overflowed before, and would again. +func (r *Relater) beginTop() bool { + r.topBegun = true + c := r.c + if !r.topHasKey { + r.topKey, r.topConstrained = c.getRelationKey(r.topSource, r.topTarget, IntersectionStateNone, r.relation == c.identityRelation, false /*ignoreConstraints*/) + r.topHasKey = true + } + // A comparison made before now may have cached a result for the key, + // unless nothing was cached since the caller read it. + if !r.topEntryRead || r.topEntryWrites != r.relation.results.writes { + r.topEntry = r.relation.cached(c, r.topKey) + } + r.topEntryValid = true + if r.topEntry&RelationComparisonResultOverflow != 0 { + r.topBegun = false + r.overflow = true + return false + } + r.relation.begin(c, r.topKey) + return true } func (c *Checker) getRelater() *Relater { @@ -2610,15 +3058,25 @@ func (c *Checker) getRelater() *Relater { } func (c *Checker) putRelater(r *Relater) { - r.maybeKeysSet.Clear() - *r = Relater{ - c: c, - maybeKeys: r.maybeKeys[:0], - maybeKeysSet: r.maybeKeysSet, - sourceStack: r.sourceStack[:0], - targetStack: r.targetStack[:0], - next: c.freeRelater, - } + if len(r.maybeKeysSet) != 0 { + clear(r.maybeKeysSet) + } + // Reset field by field, which is cheaper than assigning a whole Relater. + r.relation = nil + r.errorNode = nil + r.errorChain = nil + r.relatedInfo = nil + r.maybeKeys = r.maybeKeys[:0] + r.sourceStack, r.targetStack = r.sourceStack[:0], r.targetStack[:0] + r.sourceDepths, r.targetDepths = r.sourceDepths[:0], r.targetDepths[:0] + r.depth, r.low, r.truncated = 0, 0, false + r.topSource, r.topTarget = nil, nil + r.topKey, r.topConstrained = CacheHashKey{}, false + r.topEntry, r.topEntryValid, r.topHasKey, r.topBegun, r.topEntryRead = RelationComparisonResultNone, false, false, false, false + r.expandingFlags, r.expandingSourceDepth, r.expandingTargetDepth = ExpandingFlagsNone, 0, 0 + r.overflow = false + r.relationCount = 0 + r.next = c.freeRelater c.freeRelater = r } @@ -2842,7 +3300,7 @@ func (c *Checker) getTypeOfPropertyInType(t *Type, name string) *Type { t = c.getApparentType(t) var prop *ast.Symbol if t.flags&TypeFlagsUnionOrIntersection != 0 { - prop = c.getPropertyOfUnionOrIntersectionType(t, name, false) + prop = c.getPropertyOfType(t, name) } else { prop = c.getPropertyOfObjectType(t, name) } @@ -3120,19 +3578,48 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError // important to have well-defined behavior even in cases that shouldn't normally occur. return TernaryFalse } - id, constrained := getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, false /*ignoreConstraints*/) - if entry := r.relation.get(id); entry != RelationComparisonResultNone { - if reportErrors && entry&RelationComparisonResultFailed != 0 && entry&RelationComparisonResultOverflow == 0 { + if r.c.varianceSuperseded && r.c.isMarkerType(r.topSource) { + // The measurement at the bottom of the variance stack is discarded + // once it finishes (see getRecursiveVariances), so the comparisons + // measuring variances stop here, as if reading its incomplete + // variances. Other comparisons go on: what is computed from their + // results may be kept. + r.c.reliabilityFlags |= RelationComparisonResultReportsIncomplete + return TernaryFalse + } + if !r.topBegun && !r.beginTop() { + return TernaryFalse + } + var id CacheHashKey + var constrained bool + var entry RelationComparisonResult + if source == r.topSource && target == r.topTarget && intersectionState == IntersectionStateNone { + id, constrained = r.topKey, r.topConstrained + // The comparison read the cached result on starting, and nothing + // caches one for it before its first visit to its own pair. + if r.topEntryValid { + r.topEntryValid = false + entry = r.topEntry + } else { + entry = r.relation.cached(r.c, id) + } + } else { + id, constrained = r.c.getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, false /*ignoreConstraints*/) + entry = r.relation.cached(r.c, id) + } + if entry != RelationComparisonResultNone { + if entry&RelationComparisonResultOverflow != 0 { + // Computing the comparison overflowed, so computing this one, + // which needs it, overflows too. + r.overflow = true + return TernaryFalse + } + if reportErrors && entry&RelationComparisonResultFailed != 0 { // We are elaborating errors and the cached result is a failure not due to a comparison overflow, // so we will do the comparison again to generate an error message. + } else if related, _ := r.c.reuseRelation(entry); related { + return TernaryTrue } else { - r.c.reliabilityFlags |= entry & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) - if reportErrors && entry&RelationComparisonResultOverflow != 0 { - r.reportError(diagnostics.Excessive_complexity_comparing_types_0_and_1, r.c.TypeToString(source), r.c.TypeToString(target)) - } - if entry&RelationComparisonResultSucceeded != 0 { - return TernaryTrue - } return TernaryFalse } } @@ -3141,38 +3628,67 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError return TernaryFalse } // If source and target are already being compared, consider them related with assumptions - if r.maybeKeysSet.Has(id) { - return TernaryMaybe + if i, ok := r.maybeKeysSet[id]; ok { + return r.assume(i) } // A constrained key indicates that we have type references that reference constrained // type parameters. For such keys we also check against the key we would have gotten if all type parameters // were unconstrained. if constrained { - broadestEquivalentId, _ := getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, true /*ignoreConstraints*/) - if r.maybeKeysSet.Has(broadestEquivalentId) { - return TernaryMaybe + broadestEquivalentId, _ := r.c.getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, true /*ignoreConstraints*/) + if i, ok := r.maybeKeysSet[broadestEquivalentId]; ok { + return r.assume(i) + } + // What relates with unconstrained type parameters also relates with + // constrained ones. + if entry := r.relation.cached(r.c, broadestEquivalentId); entry&RelationComparisonResultSucceeded != 0 { + r.c.reliabilityFlags |= entry & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) + return TernaryTrue } } if len(r.sourceStack) == 100 || len(r.targetStack) == 100 { // We stop relating if we reach 100 levels of nesting. This is a backstop to catch infinite recursion // that wasn't caught by isDeeplyNestedType. It will also stop relating types that truly are over 100 // levels deep, but those are exceedingly rare. + depth := r.depth + if len(r.sourceStack) == 100 { + depth = min(depth, r.sourceDepths[0]) + } + if len(r.targetStack) == 100 { + depth = min(depth, r.targetDepths[0]) + } + r.truncate(depth) return TernaryMaybe } + depth := r.depth + r.depth++ maybeStart := len(r.maybeKeys) - r.maybeKeys = append(r.maybeKeys, id) - r.maybeKeysSet.Add(id) - saveExpandingFlags := r.expandingFlags + r.maybeKeys = append(r.maybeKeys, maybeKey{key: id, low: depth, result: TernaryMaybe}) + if r.maybeKeysSet == nil { + r.maybeKeysSet = make(map[CacheHashKey]int) + } + r.maybeKeysSet[id] = maybeStart + saveLow, saveTruncated := r.low, r.truncated + r.low, r.truncated = depth, false + saveExpandingFlags, saveExpandingSourceDepth, saveExpandingTargetDepth := r.expandingFlags, r.expandingSourceDepth, r.expandingTargetDepth if recursionFlags&RecursionFlagsSource != 0 { r.sourceStack = append(r.sourceStack, source) - if r.expandingFlags&ExpandingFlagsSource == 0 && r.c.isDeeplyNestedType(source, r.sourceStack, 3) { - r.expandingFlags |= ExpandingFlagsSource + r.sourceDepths = append(r.sourceDepths, depth) + if r.expandingFlags&ExpandingFlagsSource == 0 { + if k := r.c.deeplyNestedStart(source, r.sourceStack, 3); k >= 0 { + r.expandingFlags |= ExpandingFlagsSource + r.expandingSourceDepth = r.sourceDepths[k] + } } } if recursionFlags&RecursionFlagsTarget != 0 { r.targetStack = append(r.targetStack, target) - if r.expandingFlags&ExpandingFlagsTarget == 0 && r.c.isDeeplyNestedType(target, r.targetStack, 3) { - r.expandingFlags |= ExpandingFlagsTarget + r.targetDepths = append(r.targetDepths, depth) + if r.expandingFlags&ExpandingFlagsTarget == 0 { + if k := r.c.deeplyNestedStart(target, r.targetStack, 3); k >= 0 { + r.expandingFlags |= ExpandingFlagsTarget + r.expandingTargetDepth = r.targetDepths[k] + } } } saveReliabilityFlags := r.c.reliabilityFlags @@ -3182,50 +3698,118 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError if tr := r.c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "recursiveTypeRelatedTo_DepthLimit", map[string]any{"sourceId": source.id, "targetId": target.id, "depth": len(r.sourceStack), "targetDepth": len(r.targetStack)}) } + r.truncate(min(r.expandingSourceDepth, r.expandingTargetDepth)) result = TernaryMaybe } else { if tr := r.c.tracer; tr != nil { defer tr.Push(tracing.PhaseCheckTypes, "structuredTypeRelatedTo", map[string]any{"sourceId": source.id, "targetId": target.id}, false)() } + // The result is cached, so instantiations it needs count against + // the depth limit from here, not from wherever it is first compared + // (see "Instantiation limits" in memo.go). + r.c.beginResolution(nil, 0) result = r.structuredTypeRelatedTo(source, target, reportErrors, intersectionState) + r.c.endResolution() } - propagatingVarianceFlags := r.c.reliabilityFlags + propagatingVarianceFlags := r.c.reliabilityFlags & RelationComparisonResultReportsMask + incomplete := r.c.reliabilityFlags&RelationComparisonResultReportsIncomplete != 0 r.c.reliabilityFlags |= saveReliabilityFlags if recursionFlags&RecursionFlagsSource != 0 { r.sourceStack = r.sourceStack[:len(r.sourceStack)-1] + r.sourceDepths = r.sourceDepths[:len(r.sourceDepths)-1] } if recursionFlags&RecursionFlagsTarget != 0 { r.targetStack = r.targetStack[:len(r.targetStack)-1] + r.targetDepths = r.targetDepths[:len(r.targetDepths)-1] } - r.expandingFlags = saveExpandingFlags - if result != TernaryFalse { - if result == TernaryTrue || (len(r.sourceStack) == 0 && len(r.targetStack) == 0) { - if result == TernaryTrue || result == TernaryMaybe { - // If result is definitely true, record all maybe keys as having succeeded. Also, record Ternary.Maybe - // results as having succeeded once we reach depth 0, but never record Ternary.Unknown results. - r.resetMaybeStack(maybeStart, propagatingVarianceFlags, true) - } else { - r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) - } - } - // Note: it's intentional that we don't reset in the else case; - // we leave them on the stack such that when we hit depth zero - // above, we can report all of them as successful. - } else { + r.expandingFlags, r.expandingSourceDepth, r.expandingTargetDepth = saveExpandingFlags, saveExpandingSourceDepth, saveExpandingTargetDepth + r.depth-- + low, truncated := r.low, r.truncated + r.low, r.truncated = saveLow, saveTruncated + switch { + case r.overflow: + // The comparison was cut short, so its result and those of the + // comparisons that completed assuming it are not what computing them + // from scratch would give. Only the overflow is cached. + r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) + result = TernaryFalse + case incomplete && low >= depth: + // The result observed incomplete variances, so it is not what + // comparing from scratch would give (see getRecursiveVariances). + r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) + if result == TernaryMaybe { + result = TernaryTrue + } + case incomplete: + // As above, once the outermost comparison this one assumed completes. + r.low = min(r.low, low) + r.truncated = r.truncated || truncated + case result == TernaryFalse: // A false result goes straight into global cache (when something is false under // assumptions it will also be false without assumptions) - r.relation.set(id, RelationComparisonResultFailed|propagatingVarianceFlags) + r.relation.set(r.c, id, RelationComparisonResultFailed|propagatingVarianceFlags) r.relationCount-- r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) + case low >= depth: + // The result depends on no comparison outside of this one, so it is the + // same from scratch. Comparisons that completed assuming this one hold + // as well, unless they relied on truncation, which may not happen from + // scratch. Ternary.Unknown results are never recorded. + switch { + case result == TernaryUnknown: + r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) + case truncated: + r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) + r.relation.set(r.c, id, RelationComparisonResultSucceeded|propagatingVarianceFlags) + r.relationCount-- + default: + r.resetMaybeStack(maybeStart, propagatingVarianceFlags, true) + } + // The result no longer depends on any comparison in progress, so it + // is reported as related, the same as when it is read from the cache. + if result == TernaryMaybe { + result = TernaryTrue + } + default: + // The result holds while the comparisons it depends on are in progress, + // so it is kept until the outermost of them completes. Until then, the + // same comparison elsewhere in this one relates the same way. + for i := maybeStart; i < len(r.maybeKeys); i++ { + m := &r.maybeKeys[i] + m.low = min(m.low, low) + m.truncated = m.truncated || truncated + if result == TernaryTrue { + m.result = TernaryTrue + } + } + r.low = min(r.low, low) + r.truncated = r.truncated || truncated } return result } +// assume relates a comparison in progress, or one that completed assuming one +// in progress, as it was related so far. +func (r *Relater) assume(i int) Ternary { + m := &r.maybeKeys[i] + r.low = min(r.low, m.low) + r.truncated = r.truncated || m.truncated + return m.result +} + +// truncate records that the comparison in progress was cut short in a way +// that depends on depth and the depths above it. +func (r *Relater) truncate(depth int) { + r.low = min(r.low, depth) + r.truncated = true +} + func (r *Relater) resetMaybeStack(maybeStart int, propagatingVarianceFlags RelationComparisonResult, markAllAsSucceeded bool) { for i := maybeStart; i < len(r.maybeKeys); i++ { - r.maybeKeysSet.Delete(r.maybeKeys[i]) + key := r.maybeKeys[i].key + delete(r.maybeKeysSet, key) if markAllAsSucceeded { - r.relation.set(r.maybeKeys[i], RelationComparisonResultSucceeded|propagatingVarianceFlags) + r.relation.set(r.c, key, RelationComparisonResultSucceeded|propagatingVarianceFlags) r.relationCount-- } } @@ -3318,10 +3902,24 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo var varianceCheckFailed bool var originalErrorChain *ErrorChain saveErrorState := r.getErrorState() - relateVariances := func(sourceTypeArguments []*Type, targetTypeArguments []*Type, variances []VarianceFlags, intersectionState IntersectionState) (Ternary, bool) { + relateVariances := func(sourceTypeArguments []*Type, targetTypeArguments []*Type, variances []VarianceFlags, guessed bool, intersectionState IntersectionState) (Ternary, bool) { if result = r.typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors, intersectionState); result != TernaryFalse { return result, true } + if guessed { + // The variances are a guess for a generic type whose variances are being + // measured, or were measured in a circularity with a measurement still in + // progress (see isGuessedVariance). There is no structural fallback for + // them, so that a stricter guess never makes a comparison succeed, and the + // measurement depends on the guess monotonically. The measurement still + // learns that it observed unreliable or unmeasurable variances. + for i, v := range variances { + if v&VarianceFlagsUnmeasurable != 0 && i < len(sourceTypeArguments) { + r.c.instantiateType(sourceTypeArguments[i], r.c.reportUnmeasurableMapper) + } + } + return TernaryFalse, true + } if core.Some(variances, func(v VarianceFlags) bool { return v&VarianceFlagsAllowsStructuralFallback != 0 }) { // If some type parameter was `Unmeasurable` or `Unreliable`, and we couldn't pass by assuming it was identical, then we // have to allow a structural fallback check @@ -3455,7 +4053,7 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo nodeIsInJsFile := ast.IsInJSFile(source.alias.symbol.ValueDeclaration()) sourceTypes := r.c.fillMissingTypeArguments(source.alias.typeArguments, params, minParams, nodeIsInJsFile) targetTypes := r.c.fillMissingTypeArguments(target.alias.typeArguments, params, minParams, nodeIsInJsFile) - varianceResult, ok := relateVariances(sourceTypes, targetTypes, variances, intersectionState) + varianceResult, ok := relateVariances(sourceTypes, targetTypes, variances, r.c.isGuessedVariance(source.alias.symbol), intersectionState) if ok { return varianceResult } @@ -3595,7 +4193,8 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo case target.flags&TypeFlagsConditional != 0: // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive // conditional type and bail out with a Ternary.Maybe result. - if r.c.isDeeplyNestedType(target, r.targetStack, 10) { + if k := r.c.deeplyNestedStart(target, r.targetStack, 10); k >= 0 { + r.truncate(r.targetDepths[k]) return TernaryMaybe } c := target.AsConditionalType() @@ -3776,7 +4375,8 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo case source.flags&TypeFlagsConditional != 0: // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive // conditional type and bail out with a Ternary.Maybe result. - if r.c.isDeeplyNestedType(source, r.sourceStack, 10) { + if k := r.c.deeplyNestedStart(source, r.sourceStack, 10); k >= 0 { + r.truncate(r.sourceDepths[k]) return TernaryMaybe } if target.flags&TypeFlagsConditional != 0 { @@ -3883,13 +4483,10 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo // type references (which are intended by be compared structurally). Obtain the variance // information for the type parameters and relate the type arguments accordingly. variances := r.c.getVariances(source.Target()) - // We return Ternary.Maybe for a recursive invocation of getVariances (signaled by emptyArray). This - // effectively means we measure variance only from type parameter occurrences that aren't nested in - // recursive instantiations of the generic type. if len(variances) == 0 { return TernaryUnknown } - varianceResult, ok := relateVariances(r.c.getTypeArguments(source), r.c.getTypeArguments(target), variances, intersectionState) + varianceResult, ok := relateVariances(r.c.getTypeArguments(source), r.c.getTypeArguments(target), variances, r.c.isGuessedVariance(source.Target().symbol), intersectionState) if ok { return varianceResult } @@ -4795,7 +5392,7 @@ func (r *Relater) reportErrorResults(originalSource *Type, originalTarget *Type, r.reportRelationError(headMessage, source, target) if source.flags&TypeFlagsTypeParameter != 0 && source.symbol != nil && len(source.symbol.Declarations()) != 0 && r.c.getConstraintOfType(source) == nil { syntheticParam := r.c.cloneTypeParameter(source) - syntheticParam.AsTypeParameter().constraint = r.c.instantiateType(target, newSimpleTypeMapper(source, syntheticParam)) + syntheticParam.AsTypeParameter().constraint.intern(r.c.instantiateType(target, newSimpleTypeMapper(source, syntheticParam))) if r.c.hasNonCircularBaseConstraint(syntheticParam) { targetConstraintString := r.c.TypeToString(target) r.relatedInfo = append(r.relatedInfo, NewDiagnosticForNode(source.symbol.Declarations()[0], diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString)) @@ -4823,7 +5420,7 @@ func (r *Relater) reportRelationError(message *diagnostics.Message, source *Type if targetFlags&TypeFlagsTypeParameter != 0 && target != r.c.markerSuperTypeForCheck && target != r.c.markerSubTypeForCheck { constraint := r.c.getBaseConstraintOfType(target) switch { - case IsDistributedTypeParameter(target) && r.c.isTypeAssignableTo(generalizedSource, target.AsTypeParameter().constraint): + case IsDistributedTypeParameter(target) && r.c.isTypeAssignableTo(generalizedSource, target.AsTypeParameter().constraintOfCreation()): r.reportError(diagnostics.X_0_is_only_assignable_to_the_non_distributed_1_but_1_has_been_distributed_here, generalizedSourceType, targetType) case constraint != nil && r.c.isTypeAssignableTo(generalizedSource, constraint): r.reportError(diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2, generalizedSourceType, targetType, r.c.TypeToString(constraint)) diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go new file mode 100644 index 0000000000000..4f68d33f31c83 --- /dev/null +++ b/tsc/internal/checker/resolutions.go @@ -0,0 +1,347 @@ +package checker + +import ( + "slices" + + "github.com/microsoft/TypeScript/tsc/internal/ast" + "github.com/microsoft/TypeScript/tsc/internal/debug" +) + +// A resolution is a computation in progress: a memoized computation, a cached +// comparison, or a checked node. The innermost is the last in +// Checker.resolutions, above a root resolution for work outside any of them. +type resolution struct { + // The result computed is the memo identified by key, or the one whose + // memo state source creates for index, if either is given. + key memoKey + source memoStateSource + index int32 + // Length of the instantiation stack from which the depth limit counts: + // that on entry for a computation, or that of the enclosing resolution + // for a node. + depthStart int32 + serial uint32 // Identifies the resolution among all entered + // One more than the index of the resolution below with a key in the same + // slot of the resolving table, or 0; see resolvingTable. + belowInSlot int32 + + // A query records the effects of a memoized computation, for replay by + // reuse of its result; see memo.go. + memo bool + resolving bool // The resolution is counted in Checker.resolving as computing key + // The resolution is hidden by a cycle yield and shadowed by one + // re-entering it, until the yield ends; see beginResolving. + shadowed bool + fromCheck bool // The query began in a check; see recordFromCheck + // The computation read the incomplete result of a computation in + // progress, or was started by one that did; see effectsToDrop and + // readIncompleteAt. + readIncomplete bool + // The computation reported an error located at the current node; see + // effectsToDrop. + reportsAtCurrentNode bool + // The structured members the outermost resolution of key computes are + // available before it completes; see resolveStructuredTypeMembersUncached. + membersPublished bool + // The computation is of an instantiation cached in an instantiation + // cache; see "Instantiation limits". + instantiation bool + prevMemo int32 // Checker.memoTop on entry + // Index in Checker.deferredAttach of the first result cached by the + // computation before it had effects; see attachState. + attachStart int32 + result *memoState // Memo state of the result computed + effects *memoEffects // Allocated on first use + entry *ast.Node // Current node when the computation started + // The symbol whose member table this memo computes, if any. Keeping it + // directly lets canonical cycle entry compare declarations without + // recovering a pointer from the packed memo key. + memberSymbol *ast.Symbol + + // A type resolution is a computation that re-entering detects as a cycle; + // see beginTypeResolution. Its other fields are those of the resolution + // below it, whose work it shares. + typeResolution TypeResolution + isTypeResolution bool + prevTypeResolution int32 // Checker.typeResolutionTop on entry + prevObservedHead int32 // Checker.observedHead on entry +} + +// A memoStateSource creates the memo state of a computation in progress on +// demand, since few computations do work worth storing. +type memoStateSource interface { + stateAt(i int) *memoState + peekStateAt(i int) *memoState + popState(i int) +} + +func (c *Checker) initResolutions() { + c.resolutions = []resolution{{}} + c.syncObserving() +} + +// pushResolution pushes a resolution with every field zero and returns it. +// Popping a resolution zeroes it, so space reused above the stack needs no +// zeroing, and the caller sets only the fields it needs in place rather than +// copying in a whole resolution. +func (c *Checker) pushResolution() *resolution { + n := len(c.resolutions) + if n == 1 { + // An outermost computation, such as a query, counts its own + // instantiations; see "Instantiation limits" in memo.go. + c.instantiationCount = 0 + } + if n == cap(c.resolutions) { + c.resolutions = append(c.resolutions, resolution{}) + } else { + c.resolutions = c.resolutions[:n+1] + } + f := &c.resolutions[n] + // What a computation started by one that read an incomplete result + // computes may be derived from it too. + f.readIncomplete = n != 0 && c.readIncompleteAt(n-1) + return f +} + +// readIncompleteAt reports whether the resolution at index i read an +// incomplete result; see markReadIncomplete. +func (c *Checker) readIncompleteAt(i int) bool { + return c.resolutions[i].readIncomplete || c.readIncompleteFloor != 0 && i >= int(c.readIncompleteFloor) +} + +func (c *Checker) currentResolution() *resolution { + return &c.resolutions[len(c.resolutions)-1] +} + +// beginResolution starts a resolution for a computation, which also starts the +// depth limit of instantiations (see "Instantiation limits" in memo.go). +func (c *Checker) beginResolution(source memoStateSource, index int) { + c.appendResolution(0, source, index, int32(len(c.instantiationStack))) +} + +func (c *Checker) appendResolution(key memoKey, source memoStateSource, index int, depthBase int32) { + c.resolutionSerials++ + f := c.pushResolution() + f.key = key + if key != 0 { + h := resolvingHome(key) + f.belowInSlot = c.resolving.innermost[h] + c.resolving.innermost[h] = int32(len(c.resolutions)) + } + f.source = source + f.index = int32(index) + f.depthStart = depthBase + f.serial = c.resolutionSerials +} + +// endResolution finishes the current resolution. +func (c *Checker) endResolution() { + n := len(c.resolutions) - 1 + f := &c.resolutions[n] + debug.Assert(!f.isTypeResolution, "resolution left on the stack") + c.endResolving(f) + fromCheck := f.fromCheck + if f.memo { + clear(c.deferredAttach[f.attachStart:]) + c.deferredAttach = c.deferredAttach[:f.attachStart] + } + if f.source != nil { + f.source.popState(int(f.index)) + } + c.dropResolution(n) + if fromCheck { + c.endQueryFromCheck() + } +} + +// forgetResult makes the current resolution compute no result, for a +// computation that did not cache its result. +func (c *Checker) forgetResult() { + f := c.currentResolution() + if f.source != nil { + f.source.popState(int(f.index)) + } + c.endResolving(f) + c.unlinkResolution(f) + f.key, f.source = 0, nil +} + +// unlinkResolution removes f, the innermost resolution with its key in its +// slot of the resolving table, from the resolutions linked from the slot. +func (c *Checker) unlinkResolution(f *resolution) { + if f.key != 0 { + c.resolving.innermost[resolvingHome(f.key)] = f.belowInSlot + } +} + +// resolvingIndex returns 1 + the index in resolutions of the outermost +// computation of key in progress, or 0. +func (c *Checker) resolvingIndex(key memoKey) int { + if i, ok := c.resolvingGet(key); ok && int(i) >= c.visibleStart { + return int(i) + 1 + } + return 0 +} + +// resolvingTable counts the computations of memo cells in progress whose +// keys hash to each of its slots, so that finding none, which is nearly +// always the case, is one load. A computation in progress is a resolution +// with resolving set, which is found by searching the resolutions with a key +// in its slot only when its slot is not empty. Those are linked from the +// innermost, so that a search stays short however deep the computations in +// progress nest. +type resolvingTable struct { + counts [1 << resolvingTableBits]uint16 + innermost [1 << resolvingTableBits]int32 // One more than the index of the innermost resolution with a key in each slot, or 0 + count int +} + +const resolvingTableBits = 12 + +func resolvingHome(key memoKey) uint64 { + return spreadBits(uint64(key)) >> (64 - resolvingTableBits) +} + +// resolvingGet returns the index in resolutions of the computation of key +// recorded as in progress: the outermost, unless a cycle yield hides it and +// a computation re-entering it shadows it (see beginResolving). +func (c *Checker) resolvingGet(key memoKey) (int32, bool) { + if c.resolving.count == 0 || c.resolving.counts[resolvingHome(key)] == 0 { + return 0, false + } + return c.resolvingFind(key) +} + +//go:noinline +func (c *Checker) resolvingFind(key memoKey) (int32, bool) { + found := int32(-1) + for i := c.resolving.innermost[resolvingHome(key)] - 1; i >= 0; i = c.resolutions[i].belowInSlot - 1 { + if f := &c.resolutions[i]; f.resolving && f.key == key && f.source == nil && !f.shadowed { + found = i + } + } + return max(found, 0), found >= 0 +} + +// beginResolving records that the resolution about to be pushed computes key, +// unless a computation of key is already in progress, in which case the new +// one re-enters it as memoReentry says for its kind. It reports whether the +// resolution is recorded. +func (c *Checker) beginResolving(key memoKey) bool { + h := resolvingHome(key) + if c.resolving.counts[h] != 0 { + if i, ok := c.resolvingFind(key); ok { + if int(i) >= c.visibleStart { + c.reenter(int(i), memoReentry[key.field()]) + return false + } + // A cycle yield hides the computation in progress, so this one + // shadows it until the yield ends. + y := &c.cycleYields[len(c.cycleYields)-1] + y.shadowed = append(y.shadowed, shadowedResolving{key, i}) + c.resolutions[i].shadowed = true + } + } + c.resolving.counts[h]++ + c.resolving.count++ + return true +} + +// resolvingAnyIndex returns the index in resolutions of the computation of +// key in progress, if any, whether or not it is visible. A computation hidden +// by a cycle yield is shadowed in Checker.resolving by one re-entering it, +// until the yield ends, even once that one has ended. +func (c *Checker) resolvingAnyIndex(key memoKey) (int, bool) { + if i, ok := c.resolvingGet(key); ok { + return int(i), true + } + for _, y := range slices.Backward(c.cycleYields) { + for _, sh := range y.shadowed { + if sh.key == key { + return int(sh.index), true + } + } + } + return 0, false +} + +// endResolving records that the resolution no longer computes its key. A +// resolution that shadows another during a cycle yield ends before the yield +// restores the one it shadows, so it is still the one recorded. +func (c *Checker) endResolving(f *resolution) { + if f.resolving { + c.resolving.counts[resolvingHome(f.key)]-- + c.resolving.count-- + f.resolving = false + } +} + +func (c *Checker) findResolutionCycleStartIndex(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { + for i := c.typeResolutionTop - 1; i >= c.resolutionStart; i = int(c.resolutions[i].prevTypeResolution) - 1 { + resolution := &c.resolutions[i].typeResolution + if c.typeResolutionHasProperty(resolution) { + // The result was set before its computation finished, which + // hides a cycle below it. Only then does the search depend on + // the result. + if c.memoActive() && c.findResolutionBelow(i, target, propertyName) { + if resolution.memo != nil { + c.observeCell(resolution.memo) + } + } + return -1 + } + if resolution.target == target && resolution.propertyName == propertyName { + return i + } + } + return -1 +} + +// findResolutionBelow reports whether a type resolution of target below the +// one at index i is in progress. +func (c *Checker) findResolutionBelow(i int, target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + for i = int(c.resolutions[i].prevTypeResolution) - 1; i >= c.resolutionStart; i = int(c.resolutions[i].prevTypeResolution) - 1 { + r := &c.resolutions[i].typeResolution + if r.target == target && r.propertyName == propertyName { + return true + } + } + return false +} + +// typeResolutionHasProperty reports whether a resolution on the stack already +// has a result. Its computation is in progress, so the result is read without +// observing it; see findResolutionCycleStartIndex. +func (c *Checker) typeResolutionHasProperty(r *TypeResolution) bool { + switch r.propertyName { + case TypeSystemPropertyNameType: + return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).resolvedType.peek() != nil + case TypeSystemPropertyNameDeclaredType: + return c.typeAliasLinks.Get(r.target.(*ast.Symbol)).declaredType.peek() != nil + case TypeSystemPropertyNameResolvedTypeArguments: + return r.target.(*Type).AsTypeReference().resolvedTypeArguments.peek() != nil + case TypeSystemPropertyNameResolvedBaseTypes: + return r.target.(*Type).AsInterfaceType().baseTypesResolved + case TypeSystemPropertyNameResolvedBaseConstructorType: + return r.target.(*Type).AsInterfaceType().resolvedBaseConstructorType.peek() != nil + case TypeSystemPropertyNameResolvedReturnType: + return r.target.(*Signature).resolvedReturnType.peek() != nil + case TypeSystemPropertyNameResolvedBaseConstraint: + return r.target.(*Type).AsConstrainedType().resolvedBaseConstraint.peek() != nil + case TypeSystemPropertyNameInitializerIsUndefined: + return c.nodeLinks.Get(r.target.(*ast.Node)).flags&NodeCheckFlagsInitializerIsUndefinedComputed != 0 + case TypeSystemPropertyNameWriteType: + extra := c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).extra + return extra != nil && extra.writeType.peek() != nil + case TypeSystemPropertyNameAliasTarget: + return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget.peek() != nil + case TypeSystemPropertyNameComputedPropertyName: + return c.typeNodeLinks.Get(r.target.(*ast.Node)).resolvedType.peek() != nil + case TypeSystemPropertyNameVariances: + return c.varianceLinks.Get(r.target.(*ast.Symbol)).variances.peek() != nil + default: + // Marked as checked or resolved on entry, so it is only on the stack + // while in progress. + return false + } +} diff --git a/tsc/internal/checker/services.go b/tsc/internal/checker/services.go index ecc28ea2b2b44..9bca7bb9dc200 100644 --- a/tsc/internal/checker/services.go +++ b/tsc/internal/checker/services.go @@ -151,7 +151,7 @@ func (c *Checker) ForEachExportAndPropertyOfModule(moduleSymbol *ast.Symbol, cb if reducedType.flags&TypeFlagsStructuredType == 0 { return } - for name, symbol := range c.resolveStructuredTypeMembers(reducedType).getMembers().All() { + for name, symbol := range c.resolveStructuredTypeMembers(reducedType).getMembers(c).All() { if c.isNamedMember(symbol, name) { cb(symbol, name) } @@ -322,30 +322,37 @@ func (c *Checker) shouldTreatPropertiesOfExternalModuleAsExports(resolvedExterna func (c *Checker) GetContextualType(node *ast.Expression, contextFlags ContextFlags) *Type { if contextFlags&ContextFlagsIgnoreNodeInferences != 0 { - return c.runWithInferenceBlockedFromSourceNode(node, func() *Type { return c.getContextualType(node, contextFlags) }) + return runEditorRequest(c, node, c.inferenceBlockedFrom(node), func() *Type { return c.getContextualType(node, contextFlags) }) } return c.getContextualType(node, contextFlags) } -func (c *Checker) runWithInferenceBlockedFromSourceNode[T any](node *ast.Node, fn func() T) T { - containingCall := ast.FindAncestor(node, ast.IsCallLikeExpression) - if containingCall != nil { - toMarkSkip := node - for { - c.skipDirectInferenceNodes.Add(toMarkSkip) - toMarkSkip = toMarkSkip.Parent - if toMarkSkip == nil || toMarkSkip == containingCall { +// An editorRequest is state of an editor request that what the checker +// computes for it depends on, but is not cached under, such as the number of +// arguments typed so far. It exists only while runEditorRequest runs the +// request, discarding whatever the request caches. +type editorRequest struct { + argumentCount *int // The number of arguments to resolve a call with, if not those it has + // Inference from these nodes, the one being edited and its ancestors up + // to the call, is skipped, and call resolution reports no errors. + skipDirectInferenceNodes collections.Set[*ast.Node] + inferencePartiallyBlocked bool +} + +// inferenceBlockedFrom returns a request that blocks inference from node, an +// argument being edited, and its ancestors up to the call. +func (c *Checker) inferenceBlockedFrom(node *ast.Node) *editorRequest { + request := &editorRequest{inferencePartiallyBlocked: true} + if containingCall := ast.FindAncestor(node, ast.IsCallLikeExpression); containingCall != nil { + for n := node; ; { + request.skipDirectInferenceNodes.Add(n) + n = n.Parent + if n == nil || n == containingCall { break } } } - - c.isInferencePartiallyBlocked = true - result := c.runWithoutResolvedSignatureCaching(node, fn) - c.isInferencePartiallyBlocked = false - - c.skipDirectInferenceNodes.Clear() - return result + return request } func GetResolvedSignatureForSignatureHelp(node *ast.Node, argumentCount int, c *Checker) (*Signature, []*Signature) { @@ -353,40 +360,56 @@ func GetResolvedSignatureForSignatureHelp(node *ast.Node, argumentCount int, c * signature *Signature candidates []*Signature } - res := c.runWithoutResolvedSignatureCaching(node, func() result { - signature, candidates := c.getResolvedSignatureWorker(node, CheckModeIsForSignatureHelp, argumentCount) + res := runEditorRequest(c, node, &editorRequest{argumentCount: &argumentCount}, func() result { + signature, candidates := c.getResolvedSignatureWithCandidates(node, CheckModeIsForSignatureHelp) return result{signature, candidates} }) return res.signature, res.candidates } -func (c *Checker) runWithoutResolvedSignatureCaching[T any](node *ast.Node, fn func() T) T { +// runEditorRequest runs fn, which answers an editor request at node in the +// state of request. The calls and functions enclosing node are resolved +// again in that state, and whatever fn caches is discarded once it returns. +func runEditorRequest[T any](c *Checker, node *ast.Node, request *editorRequest, fn func() T) T { ancestorNode := ast.FindAncestor(node, ast.IsCallLikeOrFunctionLikeExpression) if ancestorNode != nil { cachedResolvedSignatures := make(map[*SignatureLinks]*Signature) cachedTypes := make(map[*ValueSymbolLinks]*Type) for ancestorNode != nil { signatureLinks := c.signatureLinks.Get(ancestorNode) - cachedResolvedSignatures[signatureLinks] = signatureLinks.resolvedSignature - signatureLinks.resolvedSignature = nil + cachedResolvedSignatures[signatureLinks] = signatureLinks.resolvedSignature.swap(nil) if ast.IsFunctionExpressionOrArrowFunction(ancestorNode) { symbolLinks := c.valueSymbolLinks.Get(c.getSymbolOfDeclaration(ancestorNode)) - resolvedType := symbolLinks.resolvedType - cachedTypes[symbolLinks] = resolvedType - symbolLinks.resolvedType = nil + cachedTypes[symbolLinks] = symbolLinks.resolvedType.swap(nil) } ancestorNode = ast.FindAncestor(ancestorNode.Parent, ast.IsCallLikeOrFunctionLikeExpression) } - result := fn() + result := runDiscardingCaches(c, request, fn) for signatureLinks, resolvedSignature := range cachedResolvedSignatures { - signatureLinks.resolvedSignature = resolvedSignature + signatureLinks.resolvedSignature.swap(resolvedSignature) } for symbolLinks, resolvedType := range cachedTypes { - symbolLinks.resolvedType = resolvedType + symbolLinks.resolvedType.swap(resolvedType) } return result } - return fn() + return runDiscardingCaches(c, request, fn) +} + +// runDiscardingCaches runs fn in the state of request, and discards whatever +// it caches: it all happens in a cycle headed below every computation, which +// ends with the request. +func runDiscardingCaches[T any](c *Checker, request *editorRequest, fn func() T) T { + debug.Assert(len(c.resolutions) == 1 && c.circularityStart == 0 && c.request == nil, "editor request inside a computation") + c.markCircular(0) + c.request = request + result := fn() + c.request = nil + // Not even the results of the participants of cycles inside the request + // are kept. + c.cycleParticipants = nil + c.endCyclesAt(0) + return result } func (c *Checker) SkipAlias(symbol *ast.Symbol) *ast.Symbol { @@ -650,7 +673,12 @@ func (c *Checker) GetTypeArgumentConstraint(node *ast.Node) *Type { func (c *Checker) getUninstantiatedSignatures(node *ast.Node) []*Signature { switch node.Kind { case ast.KindCallExpression, ast.KindDecorator: - return c.getSignaturesOfType(c.getTypeOfExpression(node.Expression()), SignatureKindCall) + expression := node.Expression() + if ast.IsDecorator(node) && ast.IsExpressionWithTypeArguments(expression) { + // The type arguments of a decorator are part of its expression. + expression = expression.Expression() + } + return c.getSignaturesOfType(c.getTypeOfExpression(expression), SignatureKindCall) case ast.KindNewExpression: return c.getSignaturesOfType(c.getTypeOfExpression(node.Expression()), SignatureKindConstruct) case ast.KindJsxSelfClosingElement, ast.KindJsxOpeningElement: @@ -814,10 +842,7 @@ func (c *Checker) GetConstantValue(node *ast.Node) any { return c.getEnumMemberValue(node).Value } - if c.symbolNodeLinks.Get(node).resolvedSymbol == nil { - c.checkExpressionCached(node) // ensure cached resolved symbol is set - } - symbol := c.symbolNodeLinks.Get(node).resolvedSymbol + symbol := c.getSymbolOfExpression(node) if symbol == nil && ast.IsEntityNameExpression(node) { symbol = c.resolveEntityName( node, @@ -838,28 +863,29 @@ func (c *Checker) GetConstantValue(node *ast.Node) any { return nil } -func (c *Checker) getResolvedSignatureWorker(node *ast.Node, checkMode CheckMode, argumentCount int) (*Signature, []*Signature) { - c.apparentArgumentCount = &argumentCount +func (c *Checker) getResolvedSignatureWithCandidates(node *ast.Node, checkMode CheckMode) (*Signature, []*Signature) { candidatesOutArray := &[]*Signature{} var res *Signature if node != nil && ast.IsParseTreeNode(node) { res = c.getResolvedSignature(node, candidatesOutArray, checkMode) } - c.apparentArgumentCount = nil return res, *candidatesOutArray } func (c *Checker) GetCandidateSignaturesForStringLiteralCompletions(call *ast.CallLikeExpression, editingArgument *ast.Node) []*Signature { // first, get candidates when inference is blocked from the source node. - candidates := c.runWithInferenceBlockedFromSourceNode(editingArgument, func() []*Signature { - _, blockedInferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0) + noArguments := 0 + blocked := c.inferenceBlockedFrom(editingArgument) + blocked.argumentCount = &noArguments + candidates := runEditorRequest(c, editingArgument, blocked, func() []*Signature { + _, blockedInferenceCandidates := c.getResolvedSignatureWithCandidates(call, CheckModeNormal) return blockedInferenceCandidates }) candidatesSet := collections.NewSetFromItems(candidates...) // next, get candidates where the source node is considered for inference. - otherCandidates := c.runWithoutResolvedSignatureCaching(editingArgument, func() []*Signature { - _, inferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0) + otherCandidates := runEditorRequest(c, editingArgument, &editorRequest{argumentCount: &noArguments}, func() []*Signature { + _, inferenceCandidates := c.getResolvedSignatureWithCandidates(call, CheckModeNormal) return inferenceCandidates }) diff --git a/tsc/internal/checker/symbolaccessibility.go b/tsc/internal/checker/symbolaccessibility.go index 204062db49de0..13ad9921a6a4e 100644 --- a/tsc/internal/checker/symbolaccessibility.go +++ b/tsc/internal/checker/symbolaccessibility.go @@ -171,18 +171,37 @@ func (c *Checker) getAlternativeContainingModules(symbol *ast.Symbol, enclosingD return nil } containingFile := ast.GetSourceFileOfNode(enclosingDeclaration) - id := ast.GetNodeId(containingFile.AsNode()) - links := c.symbolContainerLinks.Get(symbol) - if links.extendedContainersByFile == nil { - links.extendedContainersByFile = make(map[ast.NodeId][]*ast.Symbol) + // Try to make an import using an import already in the enclosing file, if possible + if results := c.getImportedContainingModules(symbol, containingFile, enclosingDeclaration); len(results) > 0 { + return results } - existing, ok := links.extendedContainersByFile[id] - if ok && existing != nil { - return existing + // No results from files already being imported by this file - expand search (not location-specific, so cached) + if results, ok := c.extendedContainers.cached(c, symbol); ok { + return results + } + return c.extendedContainers.compute(c, symbol, func() []*ast.Symbol { + return c.getExternalModuleContainers(symbol) + }) +} + +type symbolFileKey struct { + symbol *ast.Symbol + file *ast.SourceFile +} + +// getImportedContainingModules returns the modules imported by a file that +// export a symbol. The result only depends on the file, as the module names +// are resolved relative to it. +func (c *Checker) getImportedContainingModules(symbol *ast.Symbol, containingFile *ast.SourceFile, enclosingDeclaration *ast.Node) []*ast.Symbol { + if len(containingFile.Imports()) == 0 { + return nil } - var results []*ast.Symbol - if len(containingFile.Imports()) > 0 { - // Try to make an import using an import already in the enclosing file, if possible + key := symbolFileKey{symbol, containingFile} + if results, ok := c.importedContainingModules.cached(c, key); ok { + return results + } + return c.importedContainingModules.compute(c, key, func() []*ast.Symbol { + var results []*ast.Symbol for _, importRef := range containingFile.Imports() { if ast.NodeIsSynthesized(importRef) { // Synthetic names can't be resolved by `resolveExternalModuleName` - they'll cause a debug assert if they error @@ -198,23 +217,11 @@ func (c *Checker) getAlternativeContainingModules(symbol *ast.Symbol, enclosingD } results = append(results, resolvedModule) } - if len(results) > 0 { - links.extendedContainersByFile[id] = results - return results - } - } - - if links.extendedContainers != nil { - return *links.extendedContainers - } - // No results from files already being imported by this file - expand search (not location-specific, so cached) - results = c.getExternalModuleContainers(symbol) - links.extendedContainers = &results - return results + return results + }) } type externalModuleContainerIndex struct { - complete bool containersByTarget map[*ast.Symbol][]*ast.Symbol moduleOrder map[*ast.Symbol]int } @@ -227,14 +234,11 @@ func (index *externalModuleContainerIndex) add(target *ast.Symbol, container *as } func (c *Checker) getExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol { - if c.externalModuleContainers == nil { - c.buildExternalModuleContainerIndex() - } - index := c.externalModuleContainers - if !index.complete { + if _, building := c.resolvingAnyIndex(c.externalModuleContainers.key()); building { // Re-entered from an alias resolved while building the index; answer this query without it. return c.scanExternalModuleContainers(symbol) } + index := c.getExternalModuleContainerIndex() containers := index.containersByTarget[c.getResolvedTarget(symbol)] parent := c.getParentOfSymbol(symbol) parentOrder, parentIsModule := index.moduleOrder[parent] @@ -250,12 +254,15 @@ func (c *Checker) getExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol return containers } -func (c *Checker) buildExternalModuleContainerIndex() { +func (c *Checker) getExternalModuleContainerIndex() *externalModuleContainerIndex { + if index := c.externalModuleContainers.cached(c); index != nil { + return index + } + c.externalModuleContainers.begin(c) index := &externalModuleContainerIndex{ containersByTarget: make(map[*ast.Symbol][]*ast.Symbol), moduleOrder: make(map[*ast.Symbol]int, len(c.program.SourceFiles())), } - c.externalModuleContainers = index for _, file := range c.program.SourceFiles() { if !ast.IsExternalModule(file) { continue @@ -269,7 +276,9 @@ func (c *Checker) buildExternalModuleContainerIndex() { index.add(c.getResolvedTarget(exportEquals), container) } } - index.complete = true + c.externalModuleContainers.set(c, index) + c.endMemo() + return index } func (c *Checker) scanExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol { @@ -373,8 +382,7 @@ func (c *Checker) getContainersOfSymbol(symbol *ast.Symbol, enclosingDeclaration } continue } - c.checkExpressionCached(d.Parent.AsBinaryExpression().Left.Expression()) - sym := c.symbolNodeLinks.Get(d.Parent.AsBinaryExpression().Left.Expression()).resolvedSymbol + sym := c.getSymbolOfExpression(d.Parent.AsBinaryExpression().Left.Expression()) if sym != nil && !slices.Contains(candidates, sym) { candidates = append(candidates, sym) } @@ -513,15 +521,11 @@ func (c *Checker) getAccessibleSymbolChainEx(ctx accessibleSymbolChainContext) [ firstRelevantLocation = node return true }) - links := c.symbolContainerLinks.Get(ctx.symbol) - linkKey := accessibleChainCacheKey{ctx.useOnlyExternalAliasing, firstRelevantLocation, ctx.meaning} - if links.accessibleChainCache == nil { - links.accessibleChainCache = make(map[accessibleChainCacheKey][]*ast.Symbol) - } - existing, ok := links.accessibleChainCache[linkKey] - if ok { + key := accessibleChainCacheKey{ctx.symbol, ctx.useOnlyExternalAliasing, firstRelevantLocation, ctx.meaning} + if existing, ok := c.accessibleChains.cached(c, key); ok { return existing } + c.accessibleChains.begin(c, key) var result []*ast.Symbol @@ -533,7 +537,8 @@ func (c *Checker) getAccessibleSymbolChainEx(ctx accessibleSymbolChainContext) [ } return false }) - links.accessibleChainCache[linkKey] = result + c.accessibleChains.set(c, key, result) + c.endMemo() return result } @@ -573,10 +578,8 @@ func (c *Checker) getSymbolTableAliases(symbols ast.SymbolTable, tableId symbolT // Cache globals and exports tables (which are large and revisited often). // Locals tables are small and per-scope, so they are filtered but not cached. if kind == stKindGlobals || kind == stKindExports || kind == stKindResolvedExports { - if c.symbolTableAliasCache != nil { - if aliases, ok := c.symbolTableAliasCache[tableId]; ok { - return aliases - } + if aliases, ok := c.symbolTableAliasCache.get(tableId); ok { + return aliases } } var aliases []*ast.Symbol @@ -586,10 +589,7 @@ func (c *Checker) getSymbolTableAliases(symbols ast.SymbolTable, tableId symbolT } } if kind == stKindGlobals || kind == stKindExports || kind == stKindResolvedExports { - if c.symbolTableAliasCache == nil { - c.symbolTableAliasCache = make(map[symbolTableID][]*ast.Symbol) - } - c.symbolTableAliasCache[tableId] = aliases + c.symbolTableAliasCache.intern(tableId, aliases) } return aliases } @@ -882,10 +882,8 @@ func (c *Checker) someSymbolTableInScope( // synthesized table lets someSymbolTableInScope expose them during accessibility checks. func (c *Checker) getClassExpressionNameTable(location *ast.Node) ast.SymbolTable { nodeId := ast.GetNodeId(location) - if c.classExpressionNameTables != nil { - if table, ok := c.classExpressionNameTables[nodeId]; ok { - return table - } + if table, ok := c.classExpressionNameTables.get(nodeId); ok { + return table } classSymbol := c.getSymbolOfDeclaration(location) nameText := location.AsClassExpression().Name().Text() @@ -893,10 +891,7 @@ func (c *Checker) getClassExpressionNameTable(location *ast.Node) ast.SymbolTabl return nil } table := ast.SymbolTableOf(nameText, classSymbol) - if c.classExpressionNameTables == nil { - c.classExpressionNameTables = make(map[ast.NodeId]ast.SymbolTable) - } - c.classExpressionNameTables[nodeId] = table + c.classExpressionNameTables.intern(nodeId, table) return table } diff --git a/tsc/internal/checker/tracer.go b/tsc/internal/checker/tracer.go index 0fea57f8d4d70..1b82937a26c55 100644 --- a/tsc/internal/checker/tracer.go +++ b/tsc/internal/checker/tracer.go @@ -191,7 +191,7 @@ func (a *tracedTypeAdapter) ConditionalTrueType() tracing.TracedType { if a.t.flags&TypeFlagsConditional == 0 { return nil } - t := a.t.AsConditionalType().resolvedTrueType + t := a.t.AsConditionalType().resolvedTrueType.peek() if t == nil { return nil } @@ -202,7 +202,7 @@ func (a *tracedTypeAdapter) ConditionalFalseType() tracing.TracedType { if a.t.flags&TypeFlagsConditional == 0 { return nil } - t := a.t.AsConditionalType().resolvedFalseType + t := a.t.AsConditionalType().resolvedFalseType.peek() if t == nil { return nil } @@ -246,7 +246,7 @@ func (a *tracedTypeAdapter) ReferenceTypeArguments() []tracing.TracedType { if a.t.flags&TypeFlagsObject == 0 || a.t.objectFlags&ObjectFlagsReference == 0 { return nil } - return wrapTypes(a.t.AsTypeReference().resolvedTypeArguments) + return wrapTypes(a.t.AsTypeReference().resolvedTypeArguments.peek()) } func (a *tracedTypeAdapter) ReferenceNode() *ast.Node { @@ -304,7 +304,7 @@ func (a *tracedTypeAdapter) EvolvingArrayFinalType() tracing.TracedType { if a.t.flags&TypeFlagsObject == 0 || a.t.objectFlags&ObjectFlagsEvolvingArray == 0 { return nil } - t := a.t.AsEvolvingArrayType().finalArrayType + t := a.t.AsEvolvingArrayType().finalArrayType.peek() if t == nil { return nil } @@ -319,11 +319,12 @@ func (a *tracedTypeAdapter) Pattern() *ast.Node { if a.checker == nil { return nil } - return a.checker.patternForType[a.t] + p, _ := a.checker.patternForType.get(a.t) + return p } func (a *tracedTypeAdapter) RecursionIdentity() any { - return getRecursionIdentity(a.t).value + return a.checker.getRecursionIdentity(a.t).value } func (a *tracedTypeAdapter) Display() string { diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index bfa846b876822..c142ab9cba9b6 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -9,6 +9,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/core" + "github.com/microsoft/TypeScript/tsc/internal/debug" "github.com/microsoft/TypeScript/tsc/internal/evaluator" ) @@ -188,23 +189,39 @@ type SymbolReferenceLinks struct { // Links for value symbols type ValueSymbolLinks struct { - resolvedType *Type // Type of value symbol + resolvedType memo[*Type] // Type of value symbol target *ast.Symbol mapper *TypeMapper extra *valueSymbolExtra } type valueSymbolExtra struct { - writeType *Type - nameType *Type - containingType *Type // Mapped type for mapped type property, containing union or intersection type for synthetic property + writeType memo[*Type] + nameType *Type + containingType *Type // Mapped type for mapped type property, containing union or intersection type for synthetic property + instantiatedFrom *ast.Symbol // For an instantiation of an instantiated symbol, the symbol instantiated } -func (links *ValueSymbolLinks) getWriteType() *Type { +func (links *ValueSymbolLinks) cachedWriteType(c *Checker) *Type { if links.extra == nil { return nil } - return links.extra.writeType + return links.extra.writeType.cached(c) +} + +// typeOfCreation returns the type of a member its creator supplies, such as +// a member of an object literal or of the type implied by a binding pattern. +func (links *ValueSymbolLinks) typeOfCreation() *Type { + return links.resolvedType.peek() +} + +// writeTypeOfCreation returns the write type of a synthetic property, which +// its creator supplies. +func (links *ValueSymbolLinks) writeTypeOfCreation() *Type { + if links.extra == nil { + return nil + } + return links.extra.writeType.peek() } func (links *ValueSymbolLinks) getNameType() *Type { @@ -228,7 +245,19 @@ func (links *ValueSymbolLinks) setWriteType(c *Checker, typ *Type) { } links.extra = c.valueSymbolExtraArena.New() } - links.extra.writeType = typ + links.extra.writeType.set(c, typ) +} + +// setNewWriteType sets the write type of a symbol being created; see +// memo.setIdentity. +func (links *ValueSymbolLinks) setNewWriteType(c *Checker, typ *Type) { + if links.extra == nil { + if typ == nil { + return + } + links.extra = c.valueSymbolExtraArena.New() + } + links.extra.writeType.setIdentity(c, typ) } func (links *ValueSymbolLinks) setNameType(c *Checker, typ *Type) { @@ -241,6 +270,23 @@ func (links *ValueSymbolLinks) setNameType(c *Checker, typ *Type) { links.extra.nameType = typ } +func (links *ValueSymbolLinks) getInstantiatedFrom() *ast.Symbol { + if links.extra == nil { + return nil + } + return links.extra.instantiatedFrom +} + +func (links *ValueSymbolLinks) setInstantiatedFrom(c *Checker, symbol *ast.Symbol) { + if links.extra == nil { + if symbol == nil { + return + } + links.extra = c.valueSymbolExtraArena.New() + } + links.extra.instantiatedFrom = symbol +} + func (links *ValueSymbolLinks) setContainingType(c *Checker, typ *Type) { if links.extra == nil { if typ == nil { @@ -269,10 +315,10 @@ type DeferredSymbolLinks struct { // Links for alias symbols type AliasSymbolLinks struct { - immediateTarget *ast.Symbol // Immediate target of an alias. May be another alias. Do not access directly, use `checker.getImmediateAliasedSymbol` instead. - aliasTarget *ast.Symbol // Resolved (non-alias) target of an alias - referenced bool // True if alias symbol has been referenced as a value that can be emitted - typeOnlyDeclaration *ast.Node // First resolved alias declaration that makes the symbol only usable in type constructs + immediateTarget memo[*ast.Symbol] // Immediate target of an alias. May be another alias. Do not access directly, use `checker.getImmediateAliasedSymbol` instead. + aliasTarget memo[*ast.Symbol] // Resolved (non-alias) target of an alias + referenced bool // True if alias symbol has been referenced as a value that can be emitted + typeOnlyDeclaration *ast.Node // First resolved alias declaration that makes the symbol only usable in type constructs } // Links for module symbols @@ -280,7 +326,6 @@ type AliasSymbolLinks struct { type ModuleSymbolLinks struct { resolvedExports ast.SymbolTable // Resolved exports of module or combined early- and late-bound static members of a class. typeOnlyExportStarMap map[string]*ast.Node // Set on a module symbol when some of its exports were resolved through a 'export type * from "mod"' declaration - exportsChecked bool } type ReverseMappedSymbolLinks struct { @@ -305,20 +350,15 @@ type ExportTypeLinks struct { // Links for type aliases type TypeAliasLinks struct { - declaredType *Type - typeParameters []*Type // Type parameters of type alias (undefined if non-generic) - instantiations map[CacheHashKey]*Type // Instantiations of generic type alias (undefined if non-generic) - isConstructorDeclaredProperty bool + declaredType memoReported[*Type] + typeParameters []*Type // Type parameters of type alias (undefined if non-generic) + instantiations memoMap[CacheHashKey, *Type] // Instantiations of generic type alias (undefined if non-generic) } // Links for declared types (type parameters, class types, interface types, enums) type DeclaredTypeLinks struct { - declaredType *Type - interfaceChecked bool - indexSignaturesChecked bool - typeParametersChecked bool - enumChecked bool + declaredType memo[*Type] } // Links for switch clauses @@ -333,11 +373,10 @@ const ( ) type SwitchStatementLinks struct { - exhaustiveState ExhaustiveState // Switch statement exhaustiveness - switchTypesComputed bool - witnessesComputed bool - switchTypes []*Type - witnesses []string + exhaustiveState memo[ExhaustiveState] // Switch statement exhaustiveness + witnessesComputed bool + switchTypes memo[[]*Type] + witnesses []string // Syntactic, so needs no memo } type ArrayLiteralLinks struct { @@ -367,7 +406,7 @@ type SpreadLinks struct { // Links for variances of type aliases and interface types type VarianceLinks struct { - variances []VarianceFlags + variances memo[[]VarianceFlags] } type VarianceFlags uint32 @@ -390,17 +429,12 @@ type MarkedAssignmentSymbolLinks struct { } type accessibleChainCacheKey struct { + symbol *ast.Symbol useOnlyExternalAliasing bool location *ast.Node meaning ast.SymbolFlags } -type ContainingSymbolLinks struct { - extendedContainersByFile map[ast.NodeId][]*ast.Symbol // Symbols of nodes which which logically contain this one, cached by file the request is made within - extendedContainers *[]*ast.Symbol // Containers (other than the parent) which this symbol is aliased in - accessibleChainCache map[accessibleChainCacheKey][]*ast.Symbol -} - type AccessFlags uint32 const ( @@ -421,13 +455,11 @@ type NodeCheckFlags uint32 const ( NodeCheckFlagsNone NodeCheckFlags = 0 - NodeCheckFlagsTypeChecked NodeCheckFlags = 1 << 0 // Node has been type checked NodeCheckFlagsContextChecked NodeCheckFlags = 1 << 6 // Contextual types have been assigned + NodeCheckFlagsSignatureContextChecked NodeCheckFlags = 1 << 7 // Signature of a contextually typed function has been checked NodeCheckFlagsEnumValuesComputed NodeCheckFlags = 1 << 10 // Values for enum members have been computed, and any errors have been reported for them. - NodeCheckFlagsAssignmentsMarked NodeCheckFlags = 1 << 17 // Parameter assignments have been marked NodeCheckFlagsContainsClassWithPrivateIdentifiers NodeCheckFlags = 1 << 20 // Marked on all block-scoped containers containing a class with private identifiers. NodeCheckFlagsContainsSuperPropertyInStaticInitializer NodeCheckFlags = 1 << 21 // Marked on all block-scoped containers containing a static initializer with 'super.x' or 'super[x]'. - NodeCheckFlagsInCheckIdentifier NodeCheckFlags = 1 << 22 NodeCheckFlagsInitializerIsUndefined NodeCheckFlags = 1 << 24 NodeCheckFlagsInitializerIsUndefinedComputed NodeCheckFlags = 1 << 25 ) @@ -435,41 +467,43 @@ const ( // Common links type NodeLinks struct { - flags NodeCheckFlags // Set of flags specific to Node - declarationRequiresScopeChange core.Tristate // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter. - hasReportedStatementInAmbientContext bool // Cache boolean if we report statements in ambient context + flags NodeCheckFlags // Set of flags specific to Node + declarationRequiresScopeChange core.Tristate // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter. } type SymbolNodeLinks struct { - resolvedSymbol *ast.Symbol // Resolved symbol associated with node + resolvedSymbol memo[*ast.Symbol] // Resolved symbol associated with node } type TypeNodeLinks struct { - resolvedType *Type // Resolved type associated with node - outerTypeParameters *[]*Type // Outer type parameters of anonymous object type + resolvedType memo[*Type] // Resolved type associated with node + outerTypeParameters memo[*[]*Type] // Outer type parameters of anonymous object type } -func (links *TypeNodeLinks) getOuterTypeParameters() []*Type { - if links.outerTypeParameters == nil { - return nil +func (links *TypeNodeLinks) cachedOuterTypeParameters(c *Checker) []*Type { + if p := links.outerTypeParameters.cached(c); p != nil { + return *p } - return *links.outerTypeParameters + return nil } func (links *TypeNodeLinks) setOuterTypeParameters(c *Checker, types []*Type) { if types == nil { - links.outerTypeParameters = nil + links.outerTypeParameters.set(c, nil) return } - if links.outerTypeParameters == nil { - links.outerTypeParameters = c.outerTypeParameterListArena.New() - } - *links.outerTypeParameters = types + p := c.outerTypeParameterListArena.New() + *p = types + links.outerTypeParameters.set(c, p) } type ComputedNameNodeLinks struct { - hasName core.Tristate // If the node has a computable name - name string // Resolved name associated with the type of the node + name memo[computedName] // Resolved name associated with the type of the node +} + +type computedName struct { + name string + exists core.Tristate // If the node has a computable name; unknown until computed } // Links for enum members @@ -478,34 +512,30 @@ type EnumMemberLinks struct { value evaluator.Result // Constant value of enum member } -// Links for assertion expressions - -type AssertionLinks struct { - exprType *Type // Assertion expression type -} - // SourceFile links type SourceFileLinks struct { typeChecked bool unusedChecked bool externalHelpersModule *ast.Symbol + externalHelperRequests []externalHelperRequest requestedExternalEmitHelpers ExternalEmitHelpers deferredNodes collections.OrderedSet[*ast.Node] + renamedBindingElements collections.OrderedSet[*ast.Node] // Binding elements renamed in function types, which are errors unless used identifierCheckNodes []*ast.Node localJsxNamespace string localJsxFragmentNamespace string localJsxFactory *ast.EntityName localJsxFragmentFactory *ast.EntityName - jsxFragmentType *Type + jsxFragmentType memo[*Type] } // Signature specific links type SignatureLinks struct { - resolvedSignature *Signature // Cached signature of signature node or call expression - effectsSignature *Signature // Signature with possible control flow effects - decoratorSignature *Signature // Signature for decorator as if invoked by the runtime + resolvedSignature memo[*Signature] // Cached signature of signature node or call expression + effectsSignature memo[*Signature] // Signature with possible control flow effects + decoratorSignature memo[*Signature] // Signature for decorator as if invoked by the runtime } type TypeFlags uint32 @@ -719,9 +749,7 @@ const ( ObjectFlagsSingleSignatureType = 1 << 25 // A single signature type extracted from a potentially broader type ObjectFlagsIsClassInstanceClone = 1 << 26 // Type is a clone of a class instance type // Flags that require TypeFlags.Object and ObjectFlags.Reference - ObjectFlagsIdenticalBaseTypeCalculated = 1 << 27 // has had `getSingleBaseForNonAugmentingSubtype` invoked on it already - ObjectFlagsIdenticalBaseTypeExists = 1 << 28 // has a defined cachedEquivalentBaseType member - ObjectFlagsFromTypeNode = 1 << 29 // Originates in resolution of AST type node + ObjectFlagsIdenticalBaseTypeExists = 1 << 28 // has a defined cachedEquivalentBaseType member // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution ObjectFlagsIsGenericTypeComputed = 1 << 22 // IsGenericObjectType flag has been computed ObjectFlagsIsGenericObjectType = 1 << 23 // Union or intersection contains generic object type @@ -795,9 +823,12 @@ type Type struct { objectFlags ObjectFlags id TypeId kind typeKind `customlint:"protected"` - symbol *ast.Symbol - alias *TypeAlias - checker *Checker + // Height of the walk for the cached base constraint; see "Base constraint walks" + baseConstraintHeight height + generation uint16 // see Checker.typeGeneration; zero until computed + symbol *ast.Symbol + alias *TypeAlias + checker *Checker } // Enforce the layout required by the pointer conversions, on every architecture. @@ -911,6 +942,14 @@ func (t *Type) AsStructuredType() *StructuredType { return nil } +// asResolvedStructuredType is AsStructuredType for a type known to be +// structured, such as one with resolved members, without checking. +func (t *Type) asResolvedStructuredType() *StructuredType { + // SAFETY: Callers only pass types of the kinds AsStructuredType accepts, + // which embed StructuredType at offset zero. + return (*StructuredType)(unsafe.Pointer(t)) +} + func (t *Type) AsObjectType() *ObjectType { if t.kind >= typeKindObject && t.kind <= typeKindEvolvingArray { // SAFETY: Types of these kinds are structs that embed ObjectType at offset zero. @@ -1120,7 +1159,7 @@ type UniqueESSymbolType struct { type ConstrainedType struct { TypeBase - resolvedBaseConstraint *Type + resolvedBaseConstraint memo[*Type] } func (t *ConstrainedType) AsConstrainedType() *ConstrainedType { return t } @@ -1158,7 +1197,7 @@ func (t *StructuredType) ConstructSignatures() []*Signature { return slices.Clip(t.extra.signatures[t.extra.callSignatureCount:]) } -func (t *StructuredType) getMember(name string) *ast.Symbol { +func (t *StructuredType) getMember(c *Checker, name string) *ast.Symbol { if t.members != nil { return t.members.Get(name) } @@ -1170,12 +1209,12 @@ func (t *StructuredType) getMember(name string) *ast.Symbol { if index < 0 { return nil } - return t.getPropertyAt(index) + return t.getPropertyAt(c, index) } -func (t *StructuredType) getMembers() ast.SymbolTable { +func (t *StructuredType) getMembers(c *Checker) ast.SymbolTable { if t.members == nil { - if properties := t.getProperties(); len(properties) != 0 { + if properties := t.getProperties(c); len(properties) != 0 { t.members = ast.NewSymbolTableWithCapacity(len(properties)) for _, member := range properties { t.members.Set(member.Name(), member) @@ -1185,7 +1224,7 @@ func (t *StructuredType) getMembers() ast.SymbolTable { return t.members } -func (t *StructuredType) getPropertyAt(index int) *ast.Symbol { +func (t *StructuredType) getPropertyAt(c *Checker, index int) *ast.Symbol { lazy := t.getLazyState() if lazy == nil { return t.properties[index] @@ -1198,19 +1237,22 @@ func (t *StructuredType) getPropertyAt(index int) *ast.Symbol { symbol := lazy.layout.members.SymbolAt(index) baseIndex := lazy.layout.baseIndices[index] if baseIndex < 0 { - member = t.checker.instantiateSymbol(symbol, lazy.mapper) + member = c.instantiateSymbol(symbol, lazy.mapper) } else { - member = t.checker.getPropertyOfType(lazy.baseTypes[baseIndex], symbol.Name()) + member = c.getPropertyOfType(lazy.baseTypes[baseIndex], symbol.Name()) } t.properties[index] = member + if c.logResults() { + c.logPropertySlotDiscard(t, lazy, index) + } } return member } -func (t *StructuredType) getProperties() []*ast.Symbol { +func (t *StructuredType) getProperties(c *Checker) []*ast.Symbol { if lazy := t.getLazyState(); lazy != nil && !lazy.propertiesResolved { for i := range lazy.layout.members.Len() { - t.getPropertyAt(i) + t.getPropertyAt(c, i) } lazy.propertiesResolved = true } @@ -1257,7 +1299,7 @@ func (t *StructuredType) ensureExtra() *structuredTypeExtra { } func (t *StructuredType) Properties() []*ast.Symbol { - return t.getProperties() + return t.getProperties(t.checker) } // Except for tuple type references and reverse mapped types, all object types have an associated symbol. @@ -1295,9 +1337,9 @@ func (t *StructuredType) Properties() []*ast.Symbol { type ObjectType struct { StructuredType - target *Type // Target of instantiated type - mapper *TypeMapper // Type mapper for instantiated type - instantiations map[CacheHashKey]*Type // Map of type instantiations + target *Type // Target of instantiated type + mapper *TypeMapper // Type mapper for instantiated type + instantiations memoMap[CacheHashKey, *Type] // Map of type instantiations } func (t *ObjectType) AsObjectType() *ObjectType { return t } @@ -1307,7 +1349,7 @@ func (t *ObjectType) AsObjectType() *ObjectType { return t } type TypeReference struct { ObjectType node *ast.Node // TypeReferenceNode | ArrayTypeNode | TupleTypeNode when deferred, else nil - resolvedTypeArguments []*Type + resolvedTypeArguments memo[[]*Type] lazy *LazyState // Resolved member layout and instantiation state } @@ -1327,6 +1369,13 @@ type MemberLayout struct { func (t *TypeReference) AsTypeReference() *TypeReference { return t } +// typeArgumentsOfCreation returns the type arguments of a reference that is +// not deferred, which its creator supplies. +func (t *TypeReference) typeArgumentsOfCreation() []*Type { + debug.Assert(t.node == nil, "deferred type references compute their type arguments") + return t.resolvedTypeArguments.peek() +} + // InterfaceType (when generic, serves as reference to instantiation of itself) type InterfaceType struct { @@ -1336,8 +1385,8 @@ type InterfaceType struct { thisType *Type // The "this" type (nil if none) baseTypesResolved bool declaredMembersResolved bool - resolvedBaseConstructorType *Type - resolvedBaseTypes []*Type + resolvedBaseConstructorType memo[*Type] + resolvedBaseTypes memo[[]*Type] declaredMembers ast.SymbolTable // Declared members declaredCallSignatures []*Signature // Declared call signatures declaredConstructSignatures []*Signature // Declared construct signatures @@ -1427,24 +1476,13 @@ type InstantiationExpressionType struct { type MappedType struct { ObjectType declaration *ast.MappedTypeNode - typeParameter *Type - constraintType *Type - nameType *Type - templateType *Type - modifiersType *Type - resolvedApparentType *Type - containsError bool -} - -func (t *MappedType) TypeParameter() *Type { return t.typeParameter } -func (t *MappedType) ConstraintType() *Type { return t.constraintType } -func (t *MappedType) NameType() *Type { return t.nameType } -func (t *MappedType) TemplateType() *Type { return t.templateType } -func (t *MappedType) ResolveComponents(c *Checker, typ *Type) { - c.getTypeParameterFromMappedType(typ) - c.getConstraintTypeFromMappedType(typ) - c.getNameTypeFromMappedType(typ) - c.getTemplateTypeFromMappedType(typ) + typeParameter memo[*Type] + constraintType memo[*Type] + nameType memo[*Type] + templateType memo[*Type] + modifiersType memo[*Type] + resolvedApparentType memo[*Type] + containsError memo[bool] } // ReverseMappedType @@ -1461,7 +1499,7 @@ type ReverseMappedType struct { type EvolvingArrayType struct { ObjectType elementType *Type - finalArrayType *Type + finalArrayType memo[*Type] } // UnionOrIntersectionTypeData @@ -1469,9 +1507,9 @@ type EvolvingArrayType struct { type UnionOrIntersectionType struct { StructuredType types []*Type - propertyCache ast.SymbolTable // Augmented entries, except complete ones already in the non-augmented cache. - propertyCacheWithoutFunctionPropertyAugment ast.SymbolTable - resolvedProperties []*ast.Symbol + propertyCache memoMap[string, *ast.Symbol] // Augmented entries, except complete ones already in the non-augmented cache. + propertyCacheWithoutFunctionPropertyAugment memoMap[string, *ast.Symbol] + resolvedProperties memo[[]*ast.Symbol] } func (t *UnionOrIntersectionType) AsUnionOrIntersectionType() *UnionOrIntersectionType { return t } @@ -1484,10 +1522,10 @@ func (t *UnionOrIntersectionType) Types() []*Type { type UnionType struct { UnionOrIntersectionType - resolvedReducedType *Type + resolvedReducedType memo[*Type] regularType *Type origin *Type // Denormalized union, intersection, or index type in which union originates - keyPropertyName string // Property with unique unit type that exists in every object/intersection in union type + keyPropertyName memo[string] // Property with unique unit type that exists in every object/intersection in union type constituentMap map[*Type]*Type // Constituents keyed by unit type discriminants } @@ -1495,25 +1533,31 @@ type UnionType struct { type IntersectionType struct { UnionOrIntersectionType - resolvedApparentType *Type - uniqueLiteralFilledInstantiation *Type // Instantiation with type parameters mapped to never type + resolvedApparentType memo[*Type] + uniqueLiteralFilledInstantiation memo[*Type] // Instantiation with type parameters mapped to never type } // TypeParameter type TypeParameter struct { ConstrainedType - constraint *Type + constraint memo[*Type] target *Type mapper *TypeMapper isThisType bool isDistributed bool - resolvedDefaultType *Type - distributedType *Type + resolvedDefaultType memo[*Type] + distributedType *Type // The distributed counterpart, or for a distributed type parameter, its original + origin *Type // The type parameter a restrictive type parameter was made from, or the tuple target of a tuple element type parameter } func (t *TypeParameter) IsThisType() bool { return t.isThisType } +// constraintOfCreation returns the constraint of a type parameter whose +// creator supplies it, such as the this type of a tuple or a distributed type +// parameter. +func (t *TypeParameter) constraintOfCreation() *Type { return t.constraint.peek() } + // IndexFlags type IndexFlags uint32 @@ -1579,7 +1623,7 @@ type ConditionalRoot struct { isDistributive bool inferTypeParameters []*Type outerTypeParameters []*Type - instantiations map[CacheHashKey]*Type + instantiations memoMap[CacheHashKey, *Type] alias *TypeAlias } @@ -1588,13 +1632,14 @@ type ConditionalType struct { root *ConditionalRoot checkType *Type extendsType *Type - resolvedTrueType *Type - resolvedFalseType *Type - resolvedInferredTrueType *Type // The `trueType` instantiated with the `combinedMapper`, if present - resolvedDefaultConstraint *Type - resolvedConstraintOfDistributive *Type + resolvedTrueType memo[*Type] + resolvedFalseType memo[*Type] + resolvedInferredTrueType memo[*Type] // The `trueType` instantiated with the `combinedMapper`, if present + resolvedDefaultConstraint memo[*Type] + resolvedConstraintOfDistributive memo[*Type] mapper *TypeMapper combinedMapper *TypeMapper + restrictive bool // Whether the outer type parameters are mapped to restrictive forms } func (t *ConditionalType) CheckType() *Type { return t.checkType } @@ -1631,10 +1676,10 @@ type Signature struct { id SignatureId flags SignatureFlags minArgumentCount int32 - resolvedMinArgumentCount int32 + resolvedMinArgumentCount memo[int32] declaration *ast.Node parameters []*ast.Symbol - resolvedReturnType *Type + resolvedReturnType memo[*Type] target *Signature mapper *TypeMapper extra *signatureExtra @@ -1677,7 +1722,20 @@ func (s *Signature) getResolvedTypePredicate(c *Checker) *TypePredicate { return s.extra.resolvedTypePredicate } +// setResolvedTypePredicate caches the type predicate of the signature, a flag +// memo; see initResolvedTypePredicate. func (s *Signature) setResolvedTypePredicate(c *Checker, predicate *TypePredicate) { + if c.logResults() { + old := s.getResolvedTypePredicate(c) + c.logMemoDiscard(nil, memoKeyOf(s, memoTypePredicate), func() { s.initResolvedTypePredicate(c, old) }) + } + s.initResolvedTypePredicate(c, predicate) + c.setFlagMemo(memoKeyOf(s, memoTypePredicate)) +} + +// initResolvedTypePredicate sets the type predicate of a signature being +// created. +func (s *Signature) initResolvedTypePredicate(c *Checker, predicate *TypePredicate) { s.flags &^= signatureFlagsNoTypePredicate if predicate != nil && predicate == c.noTypePredicate { s.flags |= signatureFlagsNoTypePredicate diff --git a/tsc/internal/checker/types_test.go b/tsc/internal/checker/types_test.go index d19d10419bcd8..976846c4df460 100644 --- a/tsc/internal/checker/types_test.go +++ b/tsc/internal/checker/types_test.go @@ -18,8 +18,8 @@ import ( func TestCheckerNodeLinkStores(t *testing.T) { t.Parallel() f := ast.NewNodeFactory(ast.NodeFactoryHooks{}) - first := &Checker{} - second := &Checker{} + first := newBareTestChecker() + second := newBareTestChecker() nodes := make([]*ast.Node, 4096) for i := range nodes { node := f.NewIdentifier(strconv.Itoa(i)) @@ -29,18 +29,18 @@ func TestCheckerNodeLinkStores(t *testing.T) { nodes[i] = node assert.Assert(t, !first.typeNodeLinks.Has(node)) assert.Assert(t, !first.signatureLinks.Has(node)) - first.typeNodeLinks.Get(node).resolvedType = &Type{id: TypeId(i + 1)} - first.signatureLinks.Get(node).resolvedSignature = &Signature{id: SignatureId(i + 1)} - second.typeNodeLinks.Get(node).resolvedType = &Type{id: TypeId(i + 2)} - second.signatureLinks.Get(node).resolvedSignature = &Signature{id: SignatureId(i + 2)} + first.typeNodeLinks.Get(node).resolvedType.intern(&Type{id: TypeId(i + 1)}) + first.signatureLinks.Get(node).resolvedSignature.intern(&Signature{id: SignatureId(i + 1)}) + second.typeNodeLinks.Get(node).resolvedType.intern(&Type{id: TypeId(i + 2)}) + second.signatureLinks.Get(node).resolvedSignature.intern(&Signature{id: SignatureId(i + 2)}) } f.ReleaseArenas() runtime.GC() for i, node := range nodes { - assert.Equal(t, first.typeNodeLinks.Get(node).resolvedType.id, TypeId(i+1)) - assert.Equal(t, first.signatureLinks.Get(node).resolvedSignature.id, SignatureId(i+1)) - assert.Equal(t, second.typeNodeLinks.Get(node).resolvedType.id, TypeId(i+2)) - assert.Equal(t, second.signatureLinks.Get(node).resolvedSignature.id, SignatureId(i+2)) + assert.Equal(t, first.typeNodeLinks.Get(node).resolvedType.cached(first).id, TypeId(i+1)) + assert.Equal(t, first.signatureLinks.Get(node).resolvedSignature.cached(first).id, SignatureId(i+1)) + assert.Equal(t, second.typeNodeLinks.Get(node).resolvedType.cached(second).id, TypeId(i+2)) + assert.Equal(t, second.signatureLinks.Get(node).resolvedSignature.cached(second).id, SignatureId(i+2)) } clone := nodes[0].Clone(f) assert.Assert(t, !first.typeNodeLinks.Has(clone)) @@ -85,7 +85,7 @@ func TestTypeCasts(t *testing.T) { {typeKindIntersection, &IntersectionType{}, func(t *Type) any { return t.AsIntersectionType() }}, } for _, test := range tests { - c := &Checker{} + c := newBareTestChecker() typ := c.newType(TypeFlagsAny, ObjectFlagsNone, test.data.AsType(), test.kind) runtime.GC() assert.Equal(t, test.cast(typ), any(test.data)) @@ -175,14 +175,17 @@ func BenchmarkTypeListKey(b *testing.B) { } } +// newBareTestChecker returns an uninitialized checker with an empty store. +func newBareTestChecker() *Checker { + c := &Checker{memoStore: &memoStore{}} + c.initResolutions() + c.root = c + return c +} + func newCompositeTestChecker() (*Checker, []*Type) { - c := &Checker{ - strictNullChecks: true, - unionTypes: make(map[CacheHashKey]*Type), - unionOfUnionTypes: make(map[UnionOfUnionKey]*Type), - intersectionTypes: make(map[CacheHashKey]*Type), - subtypeReductionCache: make(map[CacheHashKey][]*Type), - } + c := newBareTestChecker() + c.strictNullChecks = true c.compareSymbols = c.compareSymbolsWorker c.neverType = c.newIntrinsicType(TypeFlagsNever, "never") c.unknownType = c.newIntrinsicType(TypeFlagsUnknown, "unknown") @@ -306,7 +309,7 @@ func TestIntersectionReductionAllocations(t *testing.T) { //nolint:paralleltest func TestTemporaryPropertyCounts(t *testing.T) { t.Parallel() - c := &Checker{} + c := newBareTestChecker() names := func(p *temporaryPropertyCounts) []string { var result []string for _, e := range p.entries { @@ -348,7 +351,7 @@ func TestTemporaryPropertyCounts(t *testing.T) { assert.Equal(t, counts.Size(), 0) } assert.Assert(t, c.getTemporaryPropertyCounts() != reused) - other := &Checker{} + other := newBareTestChecker() assert.Assert(t, other.getTemporaryPropertyCounts() != outer) } @@ -366,7 +369,7 @@ func TestIntersectionReductionReentrancy(t *testing.T) { assert.Assert(t, c.freePropertyCounts.next != nil) workspace := c.freePropertyCounts conflicting := c.newSymbolEx(ast.SymbolFlagsProperty, "value", ast.CheckFlagsContainsPrivate) - outer.AsUnionOrIntersectionType().propertyCacheWithoutFunctionPropertyAugment.Set("value", conflicting) + outer.AsUnionOrIntersectionType().propertyCacheWithoutFunctionPropertyAugment.intern("value", conflicting) assert.Assert(t, c.somePropertyReducesToNever(outer)) assert.Equal(t, c.freePropertyCounts, workspace) for counts := c.freePropertyCounts; counts != nil; counts = counts.next { @@ -485,10 +488,10 @@ func TestInferenceContextMappers(t *testing.T) { //nolint:paralleltest func TestCompactValueSymbolLinksLayout(t *testing.T) { t.Parallel() assert.Equal(t, unsafe.Sizeof(ValueSymbolLinks{}), 4*unsafe.Sizeof(uintptr(0))) - assert.Equal(t, unsafe.Sizeof(valueSymbolExtra{}), 3*unsafe.Sizeof(uintptr(0))) + assert.Equal(t, unsafe.Sizeof(valueSymbolExtra{}), 4*unsafe.Sizeof(uintptr(0))) c, types := newCompositeTestChecker() var links ValueSymbolLinks - assert.Assert(t, links.getWriteType() == nil) + assert.Assert(t, links.cachedWriteType(c) == nil) assert.Assert(t, links.getNameType() == nil) assert.Assert(t, links.getContainingType() == nil) links.setWriteType(c, nil) @@ -505,55 +508,15 @@ func TestCompactValueSymbolLinksLayout(t *testing.T) { other.setNameType(c, types[2]) } runtime.GC() - assert.Equal(t, links.getWriteType(), types[0]) + assert.Equal(t, links.cachedWriteType(c), types[0]) assert.Equal(t, links.getNameType(), types[1]) assert.Equal(t, links.getContainingType(), types[2]) links.setNameType(c, nil) assert.Assert(t, links.getNameType() == nil) - assert.Equal(t, links.getWriteType(), types[0]) + assert.Equal(t, links.cachedWriteType(c), types[0]) assert.Equal(t, links.getContainingType(), types[2]) } -func TestUnionIntersectionPropertyCacheSharing(t *testing.T) { - t.Parallel() - for _, intersection := range []bool{false, true} { - for _, augmentedFirst := range []bool{false, true} { - t.Run(strconv.FormatBool(intersection)+"/"+strconv.FormatBool(augmentedFirst), func(t *testing.T) { - t.Parallel() - c, _ := newCompositeTestChecker() - members := ast.NewSymbolTable() - for i := range 300 { - name := strconv.Itoa(i) - members.Set(name, c.newSymbol(ast.SymbolFlagsProperty, name)) - } - members.Set("", c.newSymbol(ast.SymbolFlagsProperty, "")) - object := c.newAnonymousType(nil, members, nil, nil, nil) - var typ *Type - if intersection { - typ = c.newIntersectionType(ObjectFlagsNone, []*Type{object, object}) - } else { - typ = c.newUnionType(ObjectFlagsNone, []*Type{object, object}) - } - data := typ.AsUnionOrIntersectionType() - for name, symbol := range members.All() { - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, !augmentedFirst), symbol) - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, augmentedFirst), symbol) - } - assert.Equal(t, data.propertyCacheWithoutFunctionPropertyAugment.Len(), members.Len()) - if !augmentedFirst { - assert.Assert(t, data.propertyCache == nil) - } - runtime.GC() - for name, symbol := range members.All() { - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, true), symbol) - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, false), symbol) - } - runtime.KeepAlive(c) - }) - } - } -} - func TestUnionIntersectionPropertyCacheModes(t *testing.T) { t.Parallel() for _, intersection := range []bool{false, true} { @@ -569,25 +532,23 @@ func TestUnionIntersectionPropertyCacheModes(t *testing.T) { data := typ.AsUnionOrIntersectionType() assert.Assert(t, c.getUnionOrIntersectionProperty(typ, "missing", true) == nil) assert.Assert(t, c.getUnionOrIntersectionProperty(typ, "missing", false) == nil) - assert.Assert(t, data.propertyCache == nil) - assert.Assert(t, data.propertyCacheWithoutFunctionPropertyAugment == nil) - data.propertyCacheWithoutFunctionPropertyAugment = ast.NewSymbolTable() - data.propertyCache = ast.NewSymbolTable() + assert.Assert(t, data.propertyCache.isEmpty()) + assert.Assert(t, data.propertyCacheWithoutFunctionPropertyAugment.isEmpty()) for _, flags := range []ast.CheckFlags{ast.CheckFlagsReadPartial, ast.CheckFlagsWritePartial} { name := strconv.Itoa(int(flags)) partial := c.newSymbolEx(ast.SymbolFlagsProperty, name, flags) complete := c.newSymbol(ast.SymbolFlagsProperty, name) - data.propertyCacheWithoutFunctionPropertyAugment.Set(name, partial) + data.propertyCacheWithoutFunctionPropertyAugment.intern(name, partial) assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, true), partial) assert.Assert(t, c.getUnionOrIntersectionProperty(typ, name, false) == nil) assert.Equal(t, c.getPropertyOfUnionOrIntersectionType(typ, name, true) == nil, flags&ast.CheckFlagsReadPartial != 0) - data.propertyCache.Set(name, complete) + data.propertyCache.intern(name, complete) assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, false), complete) } nonAugmented := c.newSymbol(ast.SymbolFlagsProperty, "different") augmented := c.newSymbol(ast.SymbolFlagsProperty, "different") - data.propertyCacheWithoutFunctionPropertyAugment.Set("different", nonAugmented) - data.propertyCache.Set("different", augmented) + data.propertyCacheWithoutFunctionPropertyAugment.intern("different", nonAugmented) + data.propertyCache.intern("different", augmented) assert.Equal(t, c.getUnionOrIntersectionProperty(typ, "different", true), nonAugmented) assert.Equal(t, c.getUnionOrIntersectionProperty(typ, "different", false), augmented) }) @@ -649,30 +610,28 @@ func TestCompactTypeNodeLinksLayout(t *testing.T) { assert.Equal(t, unsafe.Sizeof(TypeNodeLinks{}), 2*unsafe.Sizeof(uintptr(0))) c, types := newCompositeTestChecker() var links TypeNodeLinks - links.resolvedType = types[0] - assert.Assert(t, links.getOuterTypeParameters() == nil) + links.resolvedType.intern(types[0]) + assert.Assert(t, links.cachedOuterTypeParameters(c) == nil) links.setOuterTypeParameters(c, nil) - assert.Assert(t, links.outerTypeParameters == nil) + assert.Assert(t, links.outerTypeParameters.memoValue == nil) links.setOuterTypeParameters(c, []*Type{}) - assert.Assert(t, links.getOuterTypeParameters() != nil) - assert.Equal(t, len(links.getOuterTypeParameters()), 0) - entry := links.outerTypeParameters + assert.Assert(t, links.cachedOuterTypeParameters(c) != nil) + assert.Equal(t, len(links.cachedOuterTypeParameters(c)), 0) list := slices.Clone(types) links.setOuterTypeParameters(c, list) - assert.Equal(t, links.outerTypeParameters, entry) - assert.Equal(t, links.getOuterTypeParameters()[0], types[0]) + assert.Equal(t, links.cachedOuterTypeParameters(c)[0], types[0]) list[0] = types[1] - assert.Equal(t, links.getOuterTypeParameters()[0], types[1]) + assert.Equal(t, links.cachedOuterTypeParameters(c)[0], types[1]) for range 1024 { var other TypeNodeLinks other.setOuterTypeParameters(c, types) } runtime.GC() - assert.Equal(t, links.getOuterTypeParameters()[0], types[1]) - assert.Equal(t, links.resolvedType, types[0]) + assert.Equal(t, links.cachedOuterTypeParameters(c)[0], types[1]) + assert.Equal(t, links.resolvedType.cached(c), types[0]) links.setOuterTypeParameters(c, nil) - assert.Assert(t, links.getOuterTypeParameters() == nil) - assert.Equal(t, links.resolvedType, types[0]) + assert.Assert(t, links.cachedOuterTypeParameters(c) == nil) + assert.Equal(t, links.resolvedType.cached(c), types[0]) runtime.KeepAlive(c) } @@ -693,7 +652,7 @@ func TestSignatureExtra(t *testing.T) { assert.Assert(t, sig.getComposite() == nil) assert.Assert(t, sig.getIsolatedSignatureType() == nil) assert.Assert(t, sig.getResolvedTypePredicate(c) == nil) - assert.Equal(t, sig.resolvedMinArgumentCount, int32(-1)) + assert.Equal(t, sig.resolvedMinArgumentCount.peek(), int32(-1)) sig.setTypeParameters(c, nil) sig.setThisParameter(c, nil) sig.setComposite(c, nil) @@ -748,7 +707,7 @@ func TestSignatureExtra(t *testing.T) { sig.setComposite(c, nil) assert.Equal(t, sig.extra, entry) assert.Assert(t, sig.TypeParameters() == nil) - assert.Equal(t, sig.resolvedReturnType, types[0]) + assert.Equal(t, sig.resolvedReturnType.cached(c), types[0]) assert.Equal(t, sig.minArgumentCount, int32(1)) assert.Equal(t, sig.getResolvedTypePredicate(c), predicate) runtime.KeepAlive(c) diff --git a/tsc/internal/checker/utilities.go b/tsc/internal/checker/utilities.go index c4cc97fa29a1b..9cfb109e469fe 100644 --- a/tsc/internal/checker/utilities.go +++ b/tsc/internal/checker/utilities.go @@ -372,6 +372,24 @@ func (c *Checker) compareSymbolsWorker(s1, s2 *ast.Symbol) int { if s2 == nil { return -1 } + if r := c.compareSymbolDeclarationsAndNames(s1, s2); r != 0 { + return r + } + // Symbols the checker derives from a declared one, such as the members of + // mapped types, share its declaration and name. Symbol IDs are assigned in + // the order symbols are first used, so order those by how they were made. + if r := cmp.Compare(s1.Flags()&ast.SymbolFlagsTransient, s2.Flags()&ast.SymbolFlagsTransient); r != 0 { + return r + } + if r := cmp.Compare(s1.CheckFlags(), s2.CheckFlags()); r != 0 { + return r + } + // Fall back to symbol IDs. This is a last resort that should happen only when symbols have + // no declaration and duplicate names. + return cmp.Compare(ast.GetSymbolId(s1), ast.GetSymbolId(s2)) +} + +func (c *Checker) compareSymbolDeclarationsAndNames(s1, s2 *ast.Symbol) int { if len(s1.Declarations()) != 0 && len(s2.Declarations()) != 0 { if r := c.compareNodes(s1.Declarations()[0], s2.Declarations()[0]); r != 0 { return r @@ -381,12 +399,7 @@ func (c *Checker) compareSymbolsWorker(s1, s2 *ast.Symbol) int { } else if len(s2.Declarations()) != 0 { return 1 } - if r := strings.Compare(s1.Name(), s2.Name()); r != 0 { - return r - } - // Fall back to symbol IDs. This is a last resort that should happen only when symbols have - // no declaration and duplicate names. - return cmp.Compare(ast.GetSymbolId(s1), ast.GetSymbolId(s2)) + return strings.Compare(s1.Name(), s2.Name()) } func (c *Checker) compareNodes(n1, n2 *ast.Node) int { @@ -474,7 +487,7 @@ func CompareTypes(t1, t2 *Type) int { // Here we know we have references to instantiations of the same type because we have matching targets. if r1.node == nil && r2.node == nil { // Non-deferred type references with the same target are sorted by their type argument lists. - if c := compareTypeLists(t1.AsTypeReference().resolvedTypeArguments, t2.AsTypeReference().resolvedTypeArguments); c != 0 { + if c := compareTypeLists(r1.typeArgumentsOfCreation(), r2.typeArgumentsOfCreation()); c != 0 { return c } } else { @@ -488,6 +501,15 @@ func CompareTypes(t1, t2 *Type) int { return c } } + if r1.target != r2.target && r1.target.objectFlags&r2.target.objectFlags&ObjectFlagsTuple != 0 { + if c := t1.checker.compareTupleLabelDeclarations(r1.target.AsTupleType(), r2.target.AsTupleType()); c != 0 { + return c + } + } + // Array literal types follow the references they were cloned from. + if l1, l2 := t1.objectFlags&ObjectFlagsArrayLiteral != 0, t2.objectFlags&ObjectFlagsArrayLiteral != 0; l1 != l2 { + return core.IfElse(l1, 1, -1) + } } else if t1.objectFlags&ObjectFlagsReference != 0 { return -1 } else if t2.objectFlags&ObjectFlagsReference != 0 { @@ -525,6 +547,28 @@ func CompareTypes(t1, t2 *Type) int { if c := compareTypeMappers(m1, m2); c != 0 { return c } + if hasObjectLiteralMembers(t1) && hasObjectLiteralMembers(t2) { + if c := compareObjectMembers(t1, t2, true /*withTypes*/); c != 0 { + return c + } + // Fresh, regular, and widened copies of the same literal differ only in + // the flags set when they were created. + if c := int(t1.objectFlags&objectLiteralCreationFlags) - int(t2.objectFlags&objectLiteralCreationFlags); c != 0 { + return c + } + } else if t1.objectFlags&t2.objectFlags&ObjectFlagsObjectRestType != 0 { + // Rest types share the symbol of their declaration, so a rest from a union + // yields one type per constituent, distinguished by the members they keep. + // Instantiations of rest types, whose members may not be resolved yet, are + // ordered by the rest types they instantiate, which are created resolved. + if d1, d2 := t1.AsObjectType().target, t2.AsObjectType().target; d1 != nil && d2 != nil { + if c := CompareTypes(d1, d2); c != 0 { + return c + } + } else if c := compareObjectMembers(t1, t2, false /*withTypes*/); c != 0 { + return c + } + } } case t1.flags&TypeFlagsUnion != 0: // Unions are ordered by origin and then constituent type lists. @@ -580,6 +624,9 @@ func CompareTypes(t1, t2 *Type) int { if c := t1.checker.compareSymbols(t1.symbol, t2.symbol); c != 0 { return c } + if c := compareTypeParameterOrigins(t1, t2); c != 0 { + return c + } case t1.flags&TypeFlagsIndex != 0: if c := CompareTypes(t1.AsIndexType().target, t2.AsIndexType().target); c != 0 { return c @@ -594,6 +641,9 @@ func CompareTypes(t1, t2 *Type) int { if c := CompareTypes(t1.AsIndexedAccessType().indexType, t2.AsIndexedAccessType().indexType); c != 0 { return c } + if c := int(t1.AsIndexedAccessType().accessFlags) - int(t2.AsIndexedAccessType().accessFlags); c != 0 { + return c + } case t1.flags&TypeFlagsConditional != 0: if c := t1.checker.compareNodes(t1.AsConditionalType().root.node.AsNode(), t2.AsConditionalType().root.node.AsNode()); c != 0 { return c @@ -620,6 +670,20 @@ func CompareTypes(t1, t2 *Type) int { return c } } + // Types implied by binding patterns are ordered by their patterns. + if t1.flags&TypeFlagsObject != 0 { + p1, _ := t1.checker.patternForType.get(t1) + p2, _ := t2.checker.patternForType.get(t2) + if c := t1.checker.compareNodes(p1, p2); c != 0 { + return c + } + } + // Fresh literal types follow their regular counterparts. + if t1.flags&TypeFlagsFreshable != 0 { + if f1, f2 := isFreshLiteralType(t1), isFreshLiteralType(t2); f1 != f2 { + return core.IfElse(f1, 1, -1) + } + } // Fall back to type IDs. This results in type creation order for built-in types. return int(t1.id) - int(t2.id) } @@ -691,6 +755,18 @@ func compareTupleTypes(t1, t2 *TupleType) int { return 0 } +// compareTupleLabelDeclarations orders tuple targets that differ only in where +// their identically named labels are declared. The tuples must have the same +// arity, which callers establish by comparing with compareTupleTypes first. +func (c *Checker) compareTupleLabelDeclarations(t1, t2 *TupleType) int { + for i := range t1.elementInfos { + if r := c.compareNodes(t1.elementInfos[i].labeledDeclaration, t2.elementInfos[i].labeledDeclaration); r != 0 { + return r + } + } + return 0 +} + func compareElementLabels(n1, n2 *ast.Node) int { if n1 == n2 { return 0 @@ -704,6 +780,154 @@ func compareElementLabels(n1, n2 *ast.Node) int { return strings.Compare(n1.Name().Text(), n2.Name().Text()) } +// Object literal types, and types derived from them, are given their members +// at creation rather than resolving them from their symbol. +const objectLiteralCreationFlags = ObjectFlagsObjectLiteral | ObjectFlagsFreshLiteral | ObjectFlagsJSLiteral | ObjectFlagsArrayLiteral | + ObjectFlagsContainsSpread | ObjectFlagsObjectLiteralPatternWithComputedProperties | ObjectFlagsNonInferrableType | + ObjectFlagsContainsWideningType | ObjectFlagsContainsObjectOrArrayLiteral + +func hasObjectLiteralMembers(t *Type) bool { + d := t.AsObjectType() + if d.target != nil || d.mapper != nil { + return false + } + if t.symbol == nil { + // Types implied by binding patterns have no symbol. + return t.objectFlags&ObjectFlagsObjectLiteral != 0 + } + return t.symbol.Flags()&ast.SymbolFlagsObjectLiteral != 0 +} + +// compareObjectMembers orders resolved object types by what their members +// declare, and with withTypes, by the types of members of object literal +// types, which are set when the members are created. Members are created per +// type, so they are compared by what they declare rather than by identity, +// pairwise since getNamedMembers sorts the properties. +func compareObjectMembers(t1, t2 *Type, withTypes bool) int { + c := t1.checker + p1 := t1.AsStructuredType().properties + p2 := t2.AsStructuredType().properties + if n := len(p1) - len(p2); n != 0 { + return n + } + for i, s1 := range p1 { + s2 := p2[i] + if r := c.compareSymbolDeclarationsAndNames(s1, s2); r != 0 { + return r + } + if r := int(s1.Flags()&ast.SymbolFlagsOptional) - int(s2.Flags()&ast.SymbolFlagsOptional); r != 0 { + return r + } + if withTypes { + if r := CompareTypes(c.peekTypeOfObjectLiteralMember(s1), c.peekTypeOfObjectLiteralMember(s2)); r != 0 { + return r + } + } + } + return 0 +} + +// The type of a member of an object literal type is set when the member is +// created. +func (c *Checker) peekTypeOfObjectLiteralMember(s *ast.Symbol) *Type { + if links := c.valueSymbolLinks.TryGet(s); links != nil { + return links.typeOfCreation() + } + return nil +} + +type typeParameterOrigin int + +const ( + typeParameterOriginDeclared typeParameterOrigin = iota + typeParameterOriginThis + typeParameterOriginDistributed + typeParameterOriginRestrictive + typeParameterOriginTupleElement + typeParameterOriginClone +) + +func getTypeParameterOrigin(tp *TypeParameter) typeParameterOrigin { + switch { + case tp.isThisType: + return typeParameterOriginThis + case tp.isDistributed: + return typeParameterOriginDistributed + case tp.origin != nil && tp.origin.flags&TypeFlagsTypeParameter != 0: + return typeParameterOriginRestrictive + case tp.origin != nil: + return typeParameterOriginTupleElement + case tp.target != nil: + return typeParameterOriginClone + } + return typeParameterOriginDeclared +} + +// Type parameters that share a symbol are copies derived from a common original. +// Order them by how they were derived rather than by creation order. +func compareTypeParameterOrigins(t1, t2 *Type) int { + p1 := t1.AsTypeParameter() + p2 := t2.AsTypeParameter() + o1 := getTypeParameterOrigin(p1) + o2 := getTypeParameterOrigin(p2) + if o1 != o2 { + return int(o1) - int(o2) + } + switch o1 { + case typeParameterOriginThis: + // Tuple this types have no symbol; their constraint is the tuple target, + // initialized at creation. + if t1.symbol == nil { + return CompareTypes(p1.constraintOfCreation(), p2.constraintOfCreation()) + } + case typeParameterOriginDistributed: + return CompareTypes(p1.distributedType, p2.distributedType) + case typeParameterOriginRestrictive: + return CompareTypes(p1.origin, p2.origin) + case typeParameterOriginTupleElement: + if c := CompareTypes(p1.origin, p2.origin); c != 0 { + return c + } + return slices.Index(p1.origin.AsTupleType().allTypeParameters, t1) - slices.Index(p2.origin.AsTupleType().allTypeParameters, t2) + case typeParameterOriginClone: + if c := CompareTypes(p1.target, p2.target); c != 0 { + return c + } + return compareTypeMappers(getCloneOuterMapper(t1), getCloneOuterMapper(t2)) + } + return 0 +} + +// A cloned type parameter's mapper maps its target to the clone itself, +// optionally followed by the instantiation the clone was made for. Return only +// the latter so comparisons don't recurse into the clone. +func getCloneOuterMapper(t *Type) *TypeMapper { + m := t.AsTypeParameter().mapper + if m == nil { + return nil + } + if m.Kind() == TypeMapperKindComposite { + cm := castTypeMapper[CompositeTypeMapper](m, TypeMapperKindComposite) + if mapperTargetsType(cm.m1, t) { + return cm.m2 + } + } + if mapperTargetsType(m, t) { + return nil + } + return m +} + +func mapperTargetsType(m *TypeMapper, t *Type) bool { + switch m.Kind() { + case TypeMapperKindSimple: + return castTypeMapper[SimpleTypeMapper](m, TypeMapperKindSimple).target == t + case TypeMapperKindArray: + return slices.Contains(castTypeMapper[ArrayTypeMapper](m, TypeMapperKindArray).targets, t) + } + return false +} + func compareTypeLists(s1, s2 []*Type) int { if len(s1) != len(s2) { return len(s1) - len(s2) diff --git a/tsc/internal/compiler/checkerpool.go b/tsc/internal/compiler/checkerpool.go index 2ee68c75c6275..d6f1f8aa7cf4f 100644 --- a/tsc/internal/compiler/checkerpool.go +++ b/tsc/internal/compiler/checkerpool.go @@ -3,9 +3,11 @@ package compiler import ( "context" "math" + "runtime" "slices" "sort" "sync" + "sync/atomic" "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/checker" @@ -32,7 +34,9 @@ type checkerPool struct { createCheckersOnce sync.Once checkers []*checker.Checker locks []*sync.Mutex - fileAssociations map[*ast.SourceFile]*checker.Checker + fileIndices map[*ast.SourceFile]int + fileCheckers []atomic.Int32 // Index in checkers of the checker of each file, by file index + associations []int // from ProgramFactories.AssignCheckers, if set } var _ CheckerPool = (*checkerPool)(nil) @@ -302,25 +306,93 @@ func getCheckerAssociationWeights(baseWeights []int, importCounts []int) []int { return fileWeights } +/* +defaultCheckerCount picks the number of checkers when none is given. Which +checker checks a file does not change the results, and checkers take files +from each other once out of their own, so the count only trades time for +memory. Each checker builds much the same library and shared types, so +every checker adds work and memory of its own, and checking is fastest with +about one checker per CPU, up to the point where that duplicated work +dominates: + + - With 4 or 8 CPUs, measured with the process restricted to them, one + checker per logical CPU was fastest for nearly every project, and + hyperthreads were nearly as good as cores. + - With 20 CPUs (10 cores), 8 checkers were fastest for most projects; + only very large programs (VS Code) gained up to 12-16. + - Programs with few checked files gain nothing from more checkers than a + few files each, but even those with a few dozen files gain from the 4 + checkers that were the default before. + +Work is estimated from the files that are checked: those whose checking is +skipped, such as declaration files under skipLibCheck, count for nothing. +*/ +func defaultCheckerCount(program *Program) int { + procs := program.opts.CheckerProcs + if procs <= 0 { + procs = runtime.GOMAXPROCS(0) + } + files, weight := 0, 0 + for _, file := range program.files { + if !program.SkipTypeChecking(file, true /*ignoreNoCheck*/) { + files++ + weight += getCheckerAssociationBaseWeight(file.NodeCount, len(file.Text())) + } + } + limit := min(max(int(defaultCheckerLimit*math.Sqrt(float64(weight)/defaultCheckerLimitWeight)), defaultCheckerLimit), maxDefaultCheckerLimit) + return max(min(procs, limit, (files+filesPerChecker-1)/filesPerChecker), min(procs, minDefaultCheckers)) +} + +const ( + // defaultCheckerLimit is the checker count past which more checkers stop + // paying for their duplicated work, for programs up to + // defaultCheckerLimitWeight of checked work. Larger programs get more, up + // to maxDefaultCheckerLimit, with the square root of their size. + defaultCheckerLimit = 8 + defaultCheckerLimitWeight = 8_000_000 + maxDefaultCheckerLimit = 16 + // filesPerChecker is the number of checked files below which another + // checker does not pay for itself, above minDefaultCheckers. + filesPerChecker = 32 + minDefaultCheckers = 4 +) + func newCheckerPool(program *Program) *checkerPool { return newCheckerPoolWithTracing(program, nil) } func newCheckerPoolWithTracing(program *Program, tr *tracing.Tracing) *checkerPool { - checkerCount := 4 - if program.SingleThreaded() { + return newCheckerPoolWithAssignment(program, tr, nil) +} + +// newCheckerPoolWithAssignment is newCheckerPoolWithTracing with the checker +// of each file given by assign, if set; see ProgramFactories.AssignCheckers. +func newCheckerPoolWithAssignment(program *Program, tr *tracing.Tracing, assign func([]*ast.SourceFile) []int) *checkerPool { + var associations []int + var checkerCount int + if assign != nil { + associations = assign(program.files) checkerCount = 1 - } else if c := program.Options().Checkers; c != nil { - checkerCount = *c + if len(associations) > 0 { + checkerCount = slices.Max(associations) + 1 + } + } else { + if program.SingleThreaded() { + checkerCount = 1 + } else if c := program.Options().Checkers; c != nil { + checkerCount = *c + } else { + checkerCount = defaultCheckerCount(program) + } + checkerCount = max(min(checkerCount, len(program.files), 256), 1) } - checkerCount = max(min(checkerCount, len(program.files), 256), 1) - pool := &checkerPool{ - program: program, - checkers: make([]*checker.Checker, checkerCount), - locks: make([]*sync.Mutex, checkerCount), - tracing: tr, + program: program, + checkers: make([]*checker.Checker, checkerCount), + locks: make([]*sync.Mutex, checkerCount), + tracing: tr, + associations: associations, } return pool @@ -345,13 +417,19 @@ func (p *checkerPool) GetChecker(ctx context.Context, file *ast.SourceFile) (*ch // e.g. for read-only operations like obtaining an emit resolver. func (p *checkerPool) getCheckerForFileNonExclusive(file *ast.SourceFile) (*checker.Checker, func()) { p.createCheckers() - return p.fileAssociations[file], noop + return p.checkers[p.checkerIndexOf(file)], noop +} + +// checkerIndexOf returns the index in checkers of the checker the file is +// associated with: the one that checked it, or that will. +func (p *checkerPool) checkerIndexOf(file *ast.SourceFile) int { + return int(p.fileCheckers[p.fileIndices[file]].Load()) } func (p *checkerPool) getCheckerForFileExclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) { p.createCheckers() - c := p.fileAssociations[file] - idx := slices.Index(p.checkers, c) + idx := p.checkerIndexOf(file) + c := p.checkers[idx] p.locks[idx].Lock() return c, sync.OnceFunc(func() { p.locks[idx].Unlock() @@ -380,8 +458,11 @@ func (p *checkerPool) createCheckers() { wg.RunAndWait() - associations := make([]int, len(p.program.files)) - if checkerCount > 1 { + associations := p.associations + if associations == nil { + associations = make([]int, len(p.program.files)) + } + if checkerCount > 1 && p.associations == nil { baseWeights := make([]int, len(p.program.files)) importCounts := make([]int, len(p.program.files)) isDeclarationFile := make([]bool, len(p.program.files)) @@ -412,9 +493,11 @@ func (p *checkerPool) createCheckers() { fileOrder := getCheckerAssociationOrder(fileWeights, isDeclarationFile, policy.prioritizeSourceFiles) associations = getCheckerAssociationsInOrder(fileWeights, adjacentFiles, fileOrder, checkerCount, policy.balancePenaltyMultiplier) } - p.fileAssociations = make(map[*ast.SourceFile]*checker.Checker, len(p.program.files)) + p.fileIndices = make(map[*ast.SourceFile]int, len(p.program.files)) + p.fileCheckers = make([]atomic.Int32, len(p.program.files)) for i, file := range p.program.files { - p.fileAssociations[file] = p.checkers[associations[i]] + p.fileIndices[file] = i + p.fileCheckers[i].Store(int32(associations[i])) } }) } @@ -470,9 +553,12 @@ func (p *checkerPool) GetGlobalDiagnostics() []*ast.Diagnostic { return SortAndDeduplicateDiagnostics(slices.Concat(globalDiagnostics...)) } -// forEachCheckerGroupDo runs one task per checker in parallel. Each task iterates -// the provided files, processing only those assigned to its checker. Within each -// checker's set, files are visited in their original order. +// forEachCheckerGroupDo runs one task per checker in parallel, each checking +// first the files associated with it, in their original order. A task that +// runs out of files takes the last file not yet started from the checker with +// the most left, and the file is associated with its checker from then on. +// Which checker checks a file and what it checked before do not change the +// results, only how much each checker can reuse. func (p *checkerPool) forEachCheckerGroupDo(ctx context.Context, files []*ast.SourceFile, singleThreaded bool, cb func(c *checker.Checker, fileIndex int, file *ast.SourceFile)) { if ctx.Err() != nil { return @@ -481,35 +567,111 @@ func (p *checkerPool) forEachCheckerGroupDo(ctx context.Context, files []*ast.So if ctx.Err() != nil { return } - p.createCheckers() - - checkerCount := len(p.checkers) - wg := core.NewWorkGroup(core.WorkGroupConcurrency(singleThreaded)) - for checkerIdx := range checkerCount { - wg.Queue(func() { + groups := p.groupFilesByChecker(files) + if singleThreaded || len(p.checkers) == 1 { + // Tasks run one after another, so the first would take every file. + for checkerIdx, group := range groups { + c := p.checkers[checkerIdx] p.locks[checkerIdx].Lock() - defer p.locks[checkerIdx].Unlock() - for i, file := range files { + for _, i := range group { if ctx.Err() != nil { - return + break } - if checker := p.checkers[checkerIdx]; checker == p.fileAssociations[file] { - cb(checker, i, file) + cb(c, i, files[i]) + } + p.locks[checkerIdx].Unlock() + } + return + } + queues := make([]fileQueue, len(groups)) + for i, group := range groups { + queues[i].files = group + } + wg := core.NewWorkGroup(core.WorkGroupConcurrency(false)) + for checkerIdx := range groups { + wg.Queue(func() { + c := p.checkers[checkerIdx] + p.locks[checkerIdx].Lock() + defer p.locks[checkerIdx].Unlock() + for ctx.Err() == nil { + i, ok := queues[checkerIdx].popFront() + if !ok { + i, ok = stealFile(queues) + if !ok { + return + } + p.fileCheckers[p.fileIndices[files[i]]].Store(int32(checkerIdx)) } + cb(c, i, files[i]) } }) } wg.RunAndWait() } +// A fileQueue holds the indices of the files a checker has yet to start. +type fileQueue struct { + mu sync.Mutex + files []int +} + +func (q *fileQueue) popFront() (int, bool) { + q.mu.Lock() + defer q.mu.Unlock() + if len(q.files) == 0 { + return 0, false + } + i := q.files[0] + q.files = q.files[1:] + return i, true +} + +func (q *fileQueue) popBack() (int, bool) { + q.mu.Lock() + defer q.mu.Unlock() + if len(q.files) == 0 { + return 0, false + } + i := q.files[len(q.files)-1] + q.files = q.files[:len(q.files)-1] + return i, true +} + +func (q *fileQueue) len() int { + q.mu.Lock() + defer q.mu.Unlock() + return len(q.files) +} + +// stealFile takes the last file of the queue with the most files left, the +// one its checker would reach last. +func stealFile(queues []fileQueue) (int, bool) { + for { + victim, most := -1, 0 + for i := range queues { + if n := queues[i].len(); n > most { + victim, most = i, n + } + } + if victim < 0 { + return 0, false + } + if i, ok := queues[victim].popBack(); ok { + return i, true + } + } +} + // groupFilesByChecker returns the indices of files grouped by the checker each file is associated with. Files keep // their order within each group. func (p *checkerPool) groupFilesByChecker(files []*ast.SourceFile) [][]int { p.createCheckers() groups := make([][]int, len(p.checkers)) for i, file := range files { - idx := slices.Index(p.checkers, p.fileAssociations[file]) - groups[idx] = append(groups[idx], i) + if j, ok := p.fileIndices[file]; ok { + idx := int(p.fileCheckers[j].Load()) + groups[idx] = append(groups[idx], i) + } } return groups } diff --git a/tsc/internal/compiler/program.go b/tsc/internal/compiler/program.go index 06854eada0bb7..7929315e0cc55 100644 --- a/tsc/internal/compiler/program.go +++ b/tsc/internal/compiler/program.go @@ -50,6 +50,10 @@ type ProgramConfig struct { // SkipModuleResolution avoids all module and type reference resolution while // still collecting import metadata needed for emit. SkipModuleResolution bool + // CheckerProcs is the number of CPUs the checkers of the program may use + // when no checker count is given, or 0 for GOMAXPROCS; see + // defaultCheckerCount. + CheckerProcs int } type ProgramHosts struct { @@ -60,6 +64,9 @@ type ProgramHosts struct { type ProgramFactories struct { CreateCheckerPool func(*Program) CheckerPool CreateModuleResolver func(module.ResolverOptions) module.Resolver + // AssignCheckers, for testing, returns the index of the checker for each + // file of the program, in place of the usual checker count and assignment. + AssignCheckers func(files []*ast.SourceFile) []int } func (p *ProgramConfig) canUseProjectReferenceSource() bool { @@ -332,7 +339,7 @@ func NewProgram(ctx context.Context, opts ProgramOptions) (*Program, error) { if err := ctx.Err(); err != nil { return nil, err } - p.initCheckerPool(opts.CreateCheckerPool) + p.initCheckerPool(opts.CreateCheckerPool, opts.AssignCheckers) p.verifyCompilerOptions() p.collectContentMapperOptionDiagnostics() if err := ctx.Err(); err != nil { @@ -462,11 +469,11 @@ func (p *Program) ReuseProgram( } } result.replaceSyntheticImports(newFile, newSupplementalFiles) - result.initCheckerPool(createCheckerPool) + result.initCheckerPool(createCheckerPool, nil) return result, newFile, true } -func (p *Program) initCheckerPool(create func(*Program) CheckerPool) { +func (p *Program) initCheckerPool(create func(*Program) CheckerPool, assign func([]*ast.SourceFile) []int) { if !p.finishedProcessing { panic("Program must finish processing files before initializing checker pool") } @@ -474,7 +481,7 @@ func (p *Program) initCheckerPool(create func(*Program) CheckerPool) { if create != nil { p.checkerPool = create(p) } else { - pool := newCheckerPoolWithTracing(p, p.hosts.Tracing) + pool := newCheckerPoolWithAssignment(p, p.hosts.Tracing, assign) p.checkerPool = pool p.compilerCheckerPool = pool } diff --git a/tsc/internal/diagnostics/diagnosticMessages.generated.json b/tsc/internal/diagnostics/diagnosticMessages.generated.json index 300558dd1c833..3156678c7a5af 100644 --- a/tsc/internal/diagnostics/diagnosticMessages.generated.json +++ b/tsc/internal/diagnostics/diagnosticMessages.generated.json @@ -1696,6 +1696,7 @@ "Set_the_number_of_projects_to_build_concurrently_6938": "Set the number of projects to build concurrently.", "Deduplicate_packages_with_the_same_name_and_version_6939": "Deduplicate packages with the same name and version.", "Allow_loading_external_content_mapper_plugins_that_execute_code_during_compilation_6940": "Allow loading external content mapper plugins that execute code during compilation.", + "Based_on_the_available_CPUs_and_the_size_of_the_project_unless_singleThreaded_is_passed_6941": "Based on the available CPUs and the size of the project, unless --singleThreaded is passed.", "Variable_0_implicitly_has_an_1_type_7005": "Variable '{0}' implicitly has an '{1}' type.", "Parameter_0_implicitly_has_an_1_type_7006": "Parameter '{0}' implicitly has an '{1}' type.", "Member_0_implicitly_has_an_1_type_7008": "Member '{0}' implicitly has an '{1}' type.", diff --git a/tsc/internal/diagnostics/diagnosticMessages.json b/tsc/internal/diagnostics/diagnosticMessages.json index ecf6595ffd641..17a210450fef1 100644 --- a/tsc/internal/diagnostics/diagnosticMessages.json +++ b/tsc/internal/diagnostics/diagnosticMessages.json @@ -6807,6 +6807,10 @@ "category": "Message", "code": 6937 }, + "Based on the available CPUs and the size of the project, unless --singleThreaded is passed.": { + "category": "Message", + "code": 6941 + }, "Set the number of projects to build concurrently.": { "category": "Message", "code": 6938 diff --git a/tsc/internal/diagnostics/diagnostics_generated.go b/tsc/internal/diagnostics/diagnostics_generated.go index 0d016471319dd..bb97882e759f0 100644 --- a/tsc/internal/diagnostics/diagnostics_generated.go +++ b/tsc/internal/diagnostics/diagnostics_generated.go @@ -3396,6 +3396,8 @@ var Deduplicate_packages_with_the_same_name_and_version = &Message{code: 6939, c var Allow_loading_external_content_mapper_plugins_that_execute_code_during_compilation = &Message{code: 6940, category: CategoryMessage, key: "Allow_loading_external_content_mapper_plugins_that_execute_code_during_compilation_6940", text: "Allow loading external content mapper plugins that execute code during compilation."} +var Based_on_the_available_CPUs_and_the_size_of_the_project_unless_singleThreaded_is_passed = &Message{code: 6941, category: CategoryMessage, key: "Based_on_the_available_CPUs_and_the_size_of_the_project_unless_singleThreaded_is_passed_6941", text: "Based on the available CPUs and the size of the project, unless --singleThreaded is passed."} + var Variable_0_implicitly_has_an_1_type = &Message{code: 7005, category: CategoryError, key: "Variable_0_implicitly_has_an_1_type_7005", text: "Variable '{0}' implicitly has an '{1}' type."} var Parameter_0_implicitly_has_an_1_type = &Message{code: 7006, category: CategoryError, key: "Parameter_0_implicitly_has_an_1_type_7006", text: "Parameter '{0}' implicitly has an '{1}' type."} @@ -6192,6 +6194,7 @@ var allMessages = [...]**Message{ &Set_the_number_of_projects_to_build_concurrently, &Deduplicate_packages_with_the_same_name_and_version, &Allow_loading_external_content_mapper_plugins_that_execute_code_during_compilation, + &Based_on_the_available_CPUs_and_the_size_of_the_project_unless_singleThreaded_is_passed, &Variable_0_implicitly_has_an_1_type, &Parameter_0_implicitly_has_an_1_type, &Member_0_implicitly_has_an_1_type, diff --git a/tsc/internal/execute/build/buildtask.go b/tsc/internal/execute/build/buildtask.go index 5b1c87e1209ca..6a14c283078c6 100644 --- a/tsc/internal/execute/build/buildtask.go +++ b/tsc/internal/execute/build/buildtask.go @@ -271,8 +271,9 @@ func (t *BuildTask) compileAndEmit(ctx context.Context, orchestrator *Orchestrat compileTimes.BuildInfoReadTime = orchestrator.opts.Sys.Now().Sub(buildInfoReadStart) parseStart := orchestrator.opts.Sys.Now() program, programErr := compiler.NewProgram(ctx, compiler.ProgramOptions{ - Config: t.resolved, - Host: compilerHost, + Config: t.resolved, + CheckerProcs: orchestrator.checkerProcs(), + Host: compilerHost, }) if programErr != nil { t.result.exitStatus = tsc.ExitStatusCancelled diff --git a/tsc/internal/execute/build/orchestrator.go b/tsc/internal/execute/build/orchestrator.go index 310dadabf2a67..dd65eb2844522 100644 --- a/tsc/internal/execute/build/orchestrator.go +++ b/tsc/internal/execute/build/orchestrator.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "io" + "runtime" "slices" "strings" "sync/atomic" @@ -1024,13 +1025,26 @@ func (o *Orchestrator) rangeTask(f func(path tspath.PathKey, task *BuildTask)) { o.rangeTasks(o.order, f) } -func (o *Orchestrator) rangeTasks(order []*BuildTask, f func(path tspath.PathKey, task *BuildTask)) { - numRoutines := 4 +// builderCount returns the number of projects built concurrently. +func (o *Orchestrator) builderCount() int { if o.opts.Command.CompilerOptions.SingleThreaded.IsTrue() { - numRoutines = 1 + return 1 } else if builders := o.opts.Command.BuildOptions.Builders; builders != nil { - numRoutines = *builders + return *builders } + return 4 +} + +// checkerProcs returns the CPUs the checkers of each project may use: an +// equal share among the projects built concurrently, but no fewer than the 4 +// checkers of before, since projects that depend on each other are built one +// at a time, and the share would leave the rest of the CPUs idle. +func (o *Orchestrator) checkerProcs() int { + return max(runtime.GOMAXPROCS(0)/max(o.builderCount(), 1), 4) +} + +func (o *Orchestrator) rangeTasks(order []*BuildTask, f func(path tspath.PathKey, task *BuildTask)) { + numRoutines := o.builderCount() var currentTaskIndex atomic.Int64 getNextTask := func() (tspath.PathKey, *BuildTask, bool) { diff --git a/tsc/internal/execute/tsctests/tsc_test.go b/tsc/internal/execute/tsctests/tsc_test.go index ee429a826f94a..befb7578e9184 100644 --- a/tsc/internal/execute/tsctests/tsc_test.go +++ b/tsc/internal/execute/tsctests/tsc_test.go @@ -2406,12 +2406,10 @@ func TestTscIncremental(t *testing.T) { edit: func(sys *TestSys) { sys.appendFile("/home/src/workspaces/project/repro.ts", "\n// comment-only edit\n") }, - expectedDiff: "Like Strada, signature generation produces the missing-global diagnostic before semantic checking, so it is excluded from the file's semantic diagnostics.", }, { - caption: "no change", - edit: noChange.edit, - expectedDiff: "Like Strada, the cached semantic diagnostics do not include the missing-global diagnostic produced during signature generation.", + caption: "no change", + edit: noChange.edit, }, { caption: "delete build info to restore the semantic diagnostic", diff --git a/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go b/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go index 22b845a168c7f..9e2b32d740495 100644 --- a/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go +++ b/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go @@ -39,8 +39,8 @@ var c = item.toFixed( defer done() f.VerifyQuickInfoAt(t, "0", "(property) PropsA.renderItem: (item: number) => string", "") f.VerifyQuickInfoAt(t, "1", "(parameter) item: number", "") - f.VerifyQuickInfoAt(t, "2", "(property) PropsA.name: \"A\"", "comments for A") + f.VerifyQuickInfoAt(t, "2", "(property) PropsA.name: \"A\"", "comments for A") f.VerifyQuickInfoAt(t, "3", "(property) PropsA.renderItem: (item: number) => string", "") f.VerifyQuickInfoAt(t, "4", "(parameter) item: number", "") - f.VerifyQuickInfoAt(t, "5", "(property) PropsA.name: \"A\"", "comments for A") + f.VerifyQuickInfoAt(t, "5", "(property) PropsA.name: \"A\"", "comments for A") } diff --git a/tsc/internal/ls/autoimport/aliasresolver.go b/tsc/internal/ls/autoimport/aliasresolver.go index 3ac34d7d7e473..bec660bfde011 100644 --- a/tsc/internal/ls/autoimport/aliasresolver.go +++ b/tsc/internal/ls/autoimport/aliasresolver.go @@ -65,6 +65,11 @@ func (r *aliasResolver) Options() *core.CompilerOptions { } } +// SkipTypeChecking implements checker.Program. +func (r *aliasResolver) SkipTypeChecking(sourceFile *ast.SourceFile, ignoreNoCheck bool) bool { + return !ignoreNoCheck +} + // BaseDirectory implements checker.Program. func (r *aliasResolver) BaseDirectory() tspath.RootedDirectoryPath { return r.moduleResolver.BaseDirectory() diff --git a/tsc/internal/testrunner/compiler_runner.go b/tsc/internal/testrunner/compiler_runner.go index 75c8329bafba8..c7081ce8b6b44 100644 --- a/tsc/internal/testrunner/compiler_runner.go +++ b/tsc/internal/testrunner/compiler_runner.go @@ -13,6 +13,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/checker" + "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/core" "github.com/microsoft/TypeScript/tsc/internal/repo" "github.com/microsoft/TypeScript/tsc/internal/testutil" @@ -186,6 +187,14 @@ func (r *CompilerBaselineRunner) runSingleConfigTest(t *testing.T, testName stri compilerTest.verifyParentPointers(t) } +// compilerTestVaryBy adds harness options that may vary to the compiler options +// that may vary. +var compilerTestVaryBy = func() *collections.Set[string] { + s := compilerVaryBy.Clone() + s.Add("checkorder") + return s +}() + type compilerFileBasedTest struct { filename string content string @@ -198,7 +207,7 @@ func getCompilerFileBasedTest(t *testing.T, filename string) *compilerFileBasedT panic("Could not read test file: " + filename) } settings := extractCompilerSettings(content) - configurations := harnessutil.GetFileBasedTestConfigurations(t, settings, compilerVaryBy) + configurations := harnessutil.GetFileBasedTestConfigurations(t, settings, compilerTestVaryBy) return &compilerFileBasedTest{ filename: filename, content: content, diff --git a/tsc/internal/testutil/baseline/baseline.go b/tsc/internal/testutil/baseline/baseline.go index 539728ce16579..bdec15966b34a 100644 --- a/tsc/internal/testutil/baseline/baseline.go +++ b/tsc/internal/testutil/baseline/baseline.go @@ -65,7 +65,9 @@ func writeComparison(t *testing.T, actualContent string, local, reference string if actualContent == NoContent { if err := os.WriteFile(local+".delete", []byte{}, 0o644); err != nil { t.Error(fmt.Errorf("failed to write the local baseline file %s: %w", local+".delete", err)) + return } + t.Errorf("the baseline file %s should be deleted. (Run `hereby baseline-accept` if the deletion is correct.)", reference) return } if err := os.WriteFile(local, []byte(actualContent), 0o644); err != nil { diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz.go b/tsc/internal/testutil/harnessutil/checkorderfuzz.go new file mode 100644 index 0000000000000..23d61d912179b --- /dev/null +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz.go @@ -0,0 +1,447 @@ +package harnessutil + +import ( + "context" + "fmt" + "hash/fnv" + "math/rand/v2" + "os" + "regexp" + "strconv" + "strings" + "testing" + + "github.com/microsoft/TypeScript/tsc/internal/ast" + "github.com/microsoft/TypeScript/tsc/internal/checker" + "github.com/microsoft/TypeScript/tsc/internal/compiler" + "github.com/microsoft/TypeScript/tsc/internal/core" + "github.com/microsoft/TypeScript/tsc/internal/scanner" + "github.com/microsoft/TypeScript/tsc/internal/tsoptions" + "github.com/microsoft/TypeScript/tsc/internal/tspath" +) + +// Setting TS_CHECK_ORDER_FUZZ=n checks each test that has no checkOrder +// option n more times, each time in a fresh program that first answers a +// random selection of queries in a random order: the type, symbol, +// contextual type or resolved signature of a node, or the diagnostics of a +// file. A test fails if its diagnostics, or any of those results for any +// node, then differ from checking in program order, and reports the smallest list of queries that still makes them +// differ. TS_CHECK_ORDER_FUZZ_SEED=s runs only seed s. + +type fuzzQuery struct { + file *ast.SourceFile + node *ast.Node // nil to get the diagnostics of file + index int // of node in fuzzNodes(file) + kind fuzzQueryKind +} + +type fuzzQueryKind int + +const ( + fuzzQueryType fuzzQueryKind = iota + fuzzQuerySymbol + fuzzQueryContextualType + fuzzQuerySignature + fuzzQueryDiagnostics + fuzzQueryEmit + fuzzQueryHover + fuzzQueryDefinition + fuzzQuerySignatureHelp + fuzzQueryCompletion + fuzzQueryInlayHints +) + +var fuzzQueryKindNames = [...]string{ + fuzzQueryType: "type", + fuzzQuerySymbol: "symbol", + fuzzQueryContextualType: "contextual type", + fuzzQuerySignature: "signature", + fuzzQueryHover: "hover", + fuzzQueryDefinition: "definition", + fuzzQuerySignatureHelp: "signature help", + fuzzQueryCompletion: "completions", +} + +func (q fuzzQuery) String() string { + switch q.kind { + case fuzzQueryDiagnostics: + return fmt.Sprintf("diagnostics of %s", q.file.FileName()) + case fuzzQueryEmit: + return fmt.Sprintf("emit of %s", q.file.FileName()) + case fuzzQueryInlayHints: + return fmt.Sprintf("inlay hints of %s", q.file.FileName()) + } + kind := fuzzQueryKindNames[q.kind] + if ast.PositionIsSynthesized(q.node.Pos()) { + return fmt.Sprintf("%s of synthesized %s %d in %s", kind, q.node.Kind, q.index, q.file.FileName()) + } + pos := scanner.GetTokenPosOfNode(q.node, q.file, false) + line, character := scanner.GetECMALineAndUTF16CharacterOfPosition(q.file, pos) + return fmt.Sprintf("%s of %s at %s(%d,%d)", kind, scanner.GetTextOfNode(q.node), q.file.FileName(), line+1, int(character)+1) +} + +// fuzzResult is what a check order must not change: diagnostics, emitted +// files, and the result of every query of every queryable node. +type fuzzResult []string + +func fuzzCheckOrder(t *testing.T, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, harnessOptions *HarnessOptions) { + n, _ := strconv.Atoi(os.Getenv("TS_CHECK_ORDER_FUZZ")) + if t == nil || n <= 0 || harnessOptions.CheckOrder != "" && harnessOptions.CheckOrder != "default" { + return + } + options := config.CompilerOptions().Clone() + options.TraceResolution = core.TSFalse + fuzzConfig := tsoptions.NewParsedCommandLine(options, config.FileNames(), config.ProjectReferences(), config.BaseDirectory(), config.CaseSensitivity()) + fuzzConfig.ParsedConfig.ContentMappers = config.ContentMappers() + fuzzConfig.ConfigFile = config.ConfigFile + fuzzConfig.Errors = config.Errors + + ctx := context.Background() + expected := fuzzRun(t, ctx, host, fuzzConfig, nil, nil) + seeds := make([]uint64, n) + for i := range seeds { + seeds[i] = uint64(i) + } + if s := os.Getenv("TS_CHECK_ORDER_FUZZ_SEED"); s != "" { + seed, err := strconv.ParseUint(s, 10, 64) + if err != nil { + t.Fatalf("invalid TS_CHECK_ORDER_FUZZ_SEED: %v", err) + } + seeds = []uint64{seed} + } + h := fnv.New64a() + h.Write([]byte(t.Name())) + stream := h.Sum64() + for _, seed := range seeds { + rng := rand.New(rand.NewPCG(seed, stream)) + queries := fuzzQueries(createProgram(t, host, fuzzConfig), rng) + assign := fuzzAssignCheckers(rng) + diverges := func(queries []fuzzQuery) bool { + return fuzzDiff(expected, fuzzRun(t, ctx, host, fuzzConfig, assign, queries)) != "" + } + if !diverges(queries) { + continue + } + var b strings.Builder + fmt.Fprintf(&b, "check order fuzzing with TS_CHECK_ORDER_FUZZ_SEED=%d changed results", seed) + if assign != nil { + b.WriteString(" with files checked by checkers:\n") + program := createProgram(t, host, fuzzConfig).Program() + files := program.GetSourceFiles() + for i, c := range assign(files) { + if !program.IsSourceFileDefaultLibrary(files[i].PathKey()) { + fmt.Fprintf(&b, " %s: %d\n", files[i].FileName(), c) + } + } + } else { + b.WriteString("\n") + } + if diverges(nil) { + queries = nil + } else { + queries = fuzzMinimize(queries, diverges) + b.WriteString("after querying:\n") + for _, q := range queries { + fmt.Fprintf(&b, " %s\n", q) + } + } + b.WriteString("results in program order (-) and after the queries (+):\n") + b.WriteString(fuzzDiff(expected, fuzzRun(t, ctx, host, fuzzConfig, assign, queries))) + t.Error(b.String()) + } +} + +// fuzzQueries returns the queries for one seed: a random selection of every +// possible query, often only a few so that the first query matters. +func fuzzQueries(program compiler.ProgramLike, rng *rand.Rand) []fuzzQuery { + var queries []fuzzQuery + for _, file := range fuzzCheckedFiles(program) { + queries = append(queries, fuzzQuery{file: file, kind: fuzzQueryDiagnostics}, fuzzQuery{file: file, kind: fuzzQueryEmit}) + if fuzzLS { + queries = append(queries, fuzzQuery{file: file, kind: fuzzQueryInlayHints}) + } + for i, node := range fuzzNodes(file) { + for _, kind := range fuzzNodeQueryKinds(node) { + queries = append(queries, fuzzQuery{file, node, i, kind}) + } + } + } + rng.Shuffle(len(queries), func(i, j int) { queries[i], queries[j] = queries[j], queries[i] }) + if len(queries) == 0 { + return nil + } + switch rng.IntN(3) { + case 0: + return queries[:1+rng.IntN(min(len(queries), 4))] + case 1: + return queries[:rng.IntN(len(queries)+1)] + default: + return queries + } +} + +// fuzzMinimize returns a 1-minimal sublist of queries for which diverges +// still holds (Zeller's ddmin). +func fuzzMinimize(queries []fuzzQuery, diverges func([]fuzzQuery) bool) []fuzzQuery { + n := 2 + for len(queries) >= 2 { + chunk := (len(queries) + n - 1) / n + reduced := false + for start := 0; start < len(queries); start += chunk { + complement := append(queries[:start:start], queries[min(start+chunk, len(queries)):]...) + if diverges(complement) { + queries = complement + n = max(n-1, 2) + reduced = true + break + } + } + if !reduced { + if n >= len(queries) { + break + } + n = min(n*2, len(queries)) + } + } + return queries +} + +func fuzzCheckedFiles(program compiler.ProgramLike) []*ast.SourceFile { + var files []*ast.SourceFile + for _, file := range program.GetSourceFiles() { + if !program.Program().SkipTypeChecking(file, false) { + files = append(files, file) + } + } + return files +} + +// fuzzNodes returns the nodes of file that queryNodes queries. +func fuzzNodes(file *ast.SourceFile) []*ast.Node { + var nodes []*ast.Node + var visit func(n *ast.Node) bool + visit = func(n *ast.Node) bool { + if n.Flags&ast.NodeFlagsReparsed == 0 && (ast.IsExpressionNode(n) || n.Kind == ast.KindIdentifier || ast.IsDeclarationName(n)) { + nodes = append(nodes, n) + } + n.ForEachChild(visit) + return false + } + file.AsNode().ForEachChild(visit) + return nodes +} + +func fuzzHasType(node *ast.Node) bool { + return !ast.IsOmittedExpression(node) +} + +// fuzzNodeQueryKinds returns the kinds of query that apply to node. +func fuzzNodeQueryKinds(node *ast.Node) []fuzzQueryKind { + kinds := make([]fuzzQueryKind, 0, 4) + if fuzzHasType(node) { + kinds = append(kinds, fuzzQueryType) + if ast.IsExpression(node) { + kinds = append(kinds, fuzzQueryContextualType) + } + } + kinds = append(kinds, fuzzQuerySymbol) + if ast.IsCallLikeExpression(node) { + kinds = append(kinds, fuzzQuerySignature) + } + return fuzzLSNodeQueryKinds(node, kinds) +} + +// fuzzSymbolIDs matches the symbol IDs that the names of unique symbol +// properties end with, which depend on the order symbols were created in. +var fuzzSymbolIDs = regexp.MustCompile(`(\\uFFFD@[^@"]*)@\d+`) + +// fuzzQueryResult answers a query of a node, returning its result as text, +// or "" if it has none. +func fuzzQueryResult(c *checker.Checker, node *ast.Node, kind fuzzQueryKind) string { + return fuzzSymbolIDs.ReplaceAllString(fuzzQueryResultWithIDs(c, node, kind), "$1") +} + +func fuzzQueryResultWithIDs(c *checker.Checker, node *ast.Node, kind fuzzQueryKind) string { + switch kind { + case fuzzQueryType: + return c.TypeToString(c.GetTypeAtLocation(node)) + case fuzzQuerySymbol: + if symbol := c.GetSymbolAtLocation(node); symbol != nil { + return c.SymbolToString(symbol) + } + case fuzzQueryContextualType: + if t := c.GetContextualType(node, checker.ContextFlagsNone); t != nil { + return c.TypeToString(t) + } + case fuzzQuerySignature: + if signature := c.GetResolvedSignature(node); signature != nil { + return c.SignatureToStringEx(signature, nil, checker.TypeFormatFlagsNone, nil) + } + } + return "" +} + +// fuzzAssignCheckers returns, for half of the seeds, a random assignment of +// files to up to four checkers, so that results cannot depend on which +// files share a checker. +func fuzzAssignCheckers(rng *rand.Rand) func([]*ast.SourceFile) []int { + if rng.IntN(2) == 0 { + return nil + } + count := 2 + rng.IntN(3) + seed := rng.Uint64() + return func(files []*ast.SourceFile) []int { + r := rand.New(rand.NewPCG(seed, 0)) + associations := make([]int, len(files)) + for i := range associations { + associations[i] = r.IntN(count) + } + return associations + } +} + +// fuzzRun answers queries, given in the files of the program that +// fuzzQueries was given, in a fresh program, then returns its results. +func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, assign func([]*ast.SourceFile) []int, queries []fuzzQuery) fuzzResult { + program := createProgramWithCheckers(t, host, config, assign) + files := fuzzCheckedFiles(program) + // Queries name nodes of another program over the same files, so find + // the same nodes here by their index. + nodesByFile := make(map[string][]*ast.Node) + for _, file := range files { + nodesByFile[string(file.FileName())] = fuzzNodes(file) + } + var lang *fuzzLSService + if fuzzLS { + lang = fuzzLanguageService(program.Program()) + } + for _, q := range queries { + assertCheckersAtRest(program.Program()) + file := program.GetSourceFile(q.file.FileName()) + switch q.kind { + case fuzzQueryDiagnostics: + program.GetSemanticDiagnostics(ctx, file) + continue + case fuzzQueryEmit: + program.Emit(ctx, compiler.EmitOptions{TargetSourceFiles: []*ast.SourceFile{file}, WriteFile: fuzzDiscardOutput}) + continue + case fuzzQueryInlayHints: + fuzzLSResult(ctx, lang, file, nil, q.kind) + continue + } + node := nodesByFile[string(file.FileName())][q.index] + if fuzzIsLSQuery(q.kind) { + fuzzLSResult(ctx, lang, file, node, q.kind) + continue + } + c, done := program.Program().GetTypeCheckerForFile(ctx, file) + fuzzQueryResult(c, node, q.kind) + done() + } + + assertCheckersAtRest(program.Program()) + var diags []*ast.Diagnostic + diags = append(diags, program.GetSyntacticDiagnostics(ctx, nil)...) + diags = append(diags, program.GetSemanticDiagnostics(ctx, nil)...) + diags = append(diags, program.GetGlobalDiagnostics(ctx)...) + if program.Options().GetEmitDeclarations() { + diags = append(diags, program.GetDeclarationDiagnostics(ctx, nil)...) + } + var result fuzzResult + for _, d := range compiler.SortAndDeduplicateDiagnostics(diags) { + var b strings.Builder + fuzzFormatDiagnostic(&b, d, "") + result = append(result, b.String()) + } + program.Emit(ctx, compiler.EmitOptions{WriteFile: func(fileName tspath.RootedFilePath, text string, data *compiler.WriteFileData) error { + result = append(result, fmt.Sprintf("emit of %s:\n%s", fileName, text)) + return nil + }}) + for _, file := range files { + c, done := program.Program().GetTypeCheckerForFile(ctx, file) + for i, node := range nodesByFile[string(file.FileName())] { + for _, kind := range fuzzNodeQueryKinds(node) { + if fuzzIsLSQuery(kind) { + continue + } + if r := fuzzQueryResult(c, node, kind); r != "" { + result = append(result, fmt.Sprintf("%s: %s", fuzzQuery{file, node, i, kind}, r)) + } + } + } + done() + } + if lang != nil { + // Language service requests take the checker themselves. + for _, file := range files { + if r := fuzzLSResult(ctx, lang, file, nil, fuzzQueryInlayHints); r != "" { + result = append(result, fmt.Sprintf("%s: %s", fuzzQuery{file: file, kind: fuzzQueryInlayHints}, r)) + } + for i, node := range nodesByFile[string(file.FileName())] { + for _, kind := range fuzzNodeQueryKinds(node) { + if !fuzzIsLSQuery(kind) { + continue + } + if r := fuzzLSResult(ctx, lang, file, node, kind); r != "" { + result = append(result, fmt.Sprintf("%s: %s", fuzzQuery{file, node, i, kind}, r)) + } + } + } + } + } + return result +} + +func fuzzDiscardOutput(tspath.RootedFilePath, string, *compiler.WriteFileData) error { + return nil +} + +func fuzzFormatDiagnostic(b *strings.Builder, d *ast.Diagnostic, indent string) { + b.WriteString(indent) + if d.File() != nil { + line, character := scanner.GetECMALineAndUTF16CharacterOfPosition(d.File(), d.Pos()) + fmt.Fprintf(b, "%s(%d,%d): ", d.File().FileName(), line+1, int(character)+1) + } + fmt.Fprintf(b, "TS%d: %s", d.Code(), d.String()) + for _, chained := range d.MessageChain() { + b.WriteString("\n") + fuzzFormatDiagnostic(b, chained, indent+" ") + } + for _, related := range d.RelatedInformation() { + b.WriteString("\n") + fuzzFormatDiagnostic(b, related, indent+" related ") + } +} + +// fuzzDiff describes how actual differs from expected, or returns "". +func fuzzDiff(expected, actual fuzzResult) string { + count := make(map[string]int) + for _, line := range expected { + count[line]++ + } + for _, line := range actual { + count[line]-- + } + var b strings.Builder + for _, line := range expected { + if count[line] > 0 { + count[line]-- + fmt.Fprintf(&b, "- %s\n", line) + } + } + for _, line := range actual { + if count[line] < 0 { + count[line]++ + fmt.Fprintf(&b, "+ %s\n", line) + } + } + return b.String() +} + +// assertCheckersAtRest asserts that the checkers of program hold nothing of a +// request between requests; see Checker.AssertAtRest. +func assertCheckersAtRest(program *compiler.Program) { + program.ForEachCheckerParallel(func(_ int, c *checker.Checker) { + c.AssertAtRest() + }) +} diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go b/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go new file mode 100644 index 0000000000000..0d994f368a6e4 --- /dev/null +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go @@ -0,0 +1,210 @@ +package harnessutil + +import ( + "cmp" + "context" + "os" + "slices" + "sync" + + "github.com/microsoft/TypeScript/tsc/internal/ast" + "github.com/microsoft/TypeScript/tsc/internal/compiler" + "github.com/microsoft/TypeScript/tsc/internal/core" + "github.com/microsoft/TypeScript/tsc/internal/json" + "github.com/microsoft/TypeScript/tsc/internal/ls" + "github.com/microsoft/TypeScript/tsc/internal/ls/autoimport" + "github.com/microsoft/TypeScript/tsc/internal/ls/lsconv" + "github.com/microsoft/TypeScript/tsc/internal/ls/lsutil" + "github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto" + "github.com/microsoft/TypeScript/tsc/internal/scanner" + "github.com/microsoft/TypeScript/tsc/internal/sourcemap" + "github.com/microsoft/TypeScript/tsc/internal/tspath" +) + +// Setting TS_CHECK_ORDER_FUZZ_LS=1 as well also makes language service +// requests queries: hover and definition at identifiers, signature help at +// arguments, member completions after property accesses, and the inlay hints +// of a file. Their results must not differ either. +var fuzzLS = os.Getenv("TS_CHECK_ORDER_FUZZ_LS") != "" + +// fuzzLSNodeQueryKinds returns the kinds of language service request that +// apply to node. +func fuzzLSNodeQueryKinds(node *ast.Node, kinds []fuzzQueryKind) []fuzzQueryKind { + if !fuzzLS || ast.PositionIsSynthesized(node.Pos()) { + return kinds + } + if ast.IsIdentifier(node) { + kinds = append(kinds, fuzzQueryHover, fuzzQueryDefinition) + if ast.IsPropertyAccessExpression(node.Parent) && node.Parent.Name() == node { + kinds = append(kinds, fuzzQueryCompletion) + } + } + if parent := node.Parent; parent != nil && ast.IsCallOrNewExpression(parent) && node != parent.Expression() { + kinds = append(kinds, fuzzQuerySignatureHelp) + } + return kinds +} + +func fuzzIsLSQuery(kind fuzzQueryKind) bool { + return kind >= fuzzQueryHover +} + +// fuzzLanguageService returns a language service for program. +func fuzzLanguageService(program *compiler.Program) *fuzzLSService { + host := &fuzzLSHost{program: program} + // Results in lib files are converted often, and computing their line + // maps each time makes requests quadratic in their size. + var mu sync.Mutex + lineMaps := make(map[tspath.RootedFilePath]*lsconv.LSPLineMap) + host.converters = lsconv.NewConverters(lsproto.PositionEncodingKindUTF16, func(fileName tspath.RootedFilePath) *lsconv.LSPLineMap { + mu.Lock() + defer mu.Unlock() + if lineMap, ok := lineMaps[fileName]; ok { + return lineMap + } + var lineMap *lsconv.LSPLineMap + if file := program.GetSourceFile(fileName); file != nil { + lineMap = lsconv.ComputeLSPLineStarts(file.Text()) + } + lineMaps[fileName] = lineMap + return lineMap + }) + return &fuzzLSService{ls.NewLanguageService(fuzzProjectID{}, program, host, ""), host.converters, program} +} + +type fuzzLSService struct { + *ls.LanguageService + converters *lsconv.Converters + program *compiler.Program +} + +// fuzzLSResult makes the language service request of kind at node, or for +// the whole file if node is nil, returning its result as text. +func fuzzLSResult(ctx context.Context, lang *fuzzLSService, file *ast.SourceFile, node *ast.Node, kind fuzzQueryKind) string { + uri := lsconv.FileNameToDocumentURI(file.FileName()) + if uri.FileName() != file.FileName() { + // The language service cannot find a file whose name a URI does not + // preserve. + return "" + } + position := func(pos int) lsproto.Position { + p, _ := lang.converters.ToLSPPosition(file, core.TextPos(pos)) + return p + } + var result any + var err error + defer assertCheckersAtRest(lang.program) + switch kind { + case fuzzQueryHover: + result, err = lang.ProvideHover(ctx, &lsproto.HoverParams{ + TextDocument: lsproto.TextDocumentIdentifier{Uri: uri}, + Position: position(scanner.GetTokenPosOfNode(node, file, false)), + }) + case fuzzQueryDefinition: + result, err = lang.ProvideDefinition(ctx, uri, position(scanner.GetTokenPosOfNode(node, file, false))) + case fuzzQuerySignatureHelp: + result, err = lang.ProvideSignatureHelp(ctx, uri, position(scanner.GetTokenPosOfNode(node, file, false)), nil) + case fuzzQueryCompletion: + var completions lsproto.CompletionResponse + completions, err = lang.ProvideCompletion(ctx, uri, position(node.End()), nil) + if completions.List != nil { + // Editors sort items by sort text and label, and the language + // service leaves those that tie in no particular order. + slices.SortStableFunc(completions.List.Items, func(a, b *lsproto.CompletionItem) int { + return cmp.Or(cmp.Compare(fuzzSortText(a), fuzzSortText(b)), cmp.Compare(a.Label, b.Label)) + }) + } + result = completions + case fuzzQueryInlayHints: + result, err = lang.ProvideInlayHint(ctx, &lsproto.InlayHintParams{ + TextDocument: lsproto.TextDocumentIdentifier{Uri: uri}, + Range: lsproto.Range{Start: position(0), End: position(len(file.Text()))}, + }) + } + if err != nil { + return "error: " + err.Error() + } + text, err := json.Marshal(result) + if err != nil { + return "error: " + err.Error() + } + if string(text) == "null" { + return "" + } + return string(text) +} + +func fuzzSortText(item *lsproto.CompletionItem) string { + if item.SortText == nil { + return "" + } + return *item.SortText +} + +type fuzzProjectID struct{} + +func (fuzzProjectID) String() string { return "fuzz" } + +// fuzzLSHost is the language service host of a program alone. +type fuzzLSHost struct { + program *compiler.Program + converters *lsconv.Converters +} + +func (h *fuzzLSHost) CaseSensitivity() tspath.CaseSensitivity { + return h.program.Host().FS().CaseSensitivity() +} + +func (h *fuzzLSHost) ReadFile(path tspath.RootedFilePath) (string, bool) { + return h.program.Host().FS().ReadFile(path) +} + +func (h *fuzzLSHost) Converters() *lsconv.Converters { + return h.converters +} + +func (h *fuzzLSHost) GetPreferences(activeFile string) lsutil.UserPreferences { + preferences := lsutil.NewDefaultUserPreferences() + preferences.IncludeCompletionsForModuleExports = core.TSFalse + preferences.IncludeCompletionsForImportStatements = core.TSFalse + preferences.InlayHintsPreferences = lsutil.InlayHintsPreferences{ + IncludeInlayEnumMemberValueHints: core.TSTrue, + IncludeInlayFunctionLikeReturnTypeHints: core.TSTrue, + IncludeInlayFunctionParameterTypeHints: core.TSTrue, + IncludeInlayParameterNameHints: lsutil.IncludeInlayParameterNameHintsAll, + IncludeInlayPropertyDeclarationTypeHints: core.TSTrue, + IncludeInlayVariableTypeHints: core.TSTrue, + } + return preferences +} + +func (h *fuzzLSHost) GetWorkspaceFolders() []ls.WorkspaceFolder { + return nil +} + +func (h *fuzzLSHost) GetECMALineInfo(fileName tspath.RootedFilePath) *sourcemap.ECMALineInfo { + if file := h.program.GetSourceFile(fileName); file != nil { + return sourcemap.CreateECMALineInfo(file.Text(), file.ECMALineMap()) + } + return nil +} + +func (h *fuzzLSHost) AutoImportRegistry() *autoimport.Registry { + return nil +} + +func (h *fuzzLSHost) ReadDirectory(path tspath.RootedDirectoryPath, extensions []string, excludes []string, includes []string, depth int) []tspath.RootedFilePath { + return nil +} + +func (h *fuzzLSHost) GetDirectories(path tspath.RootedDirectoryPath) []string { + return nil +} + +func (h *fuzzLSHost) DirectoryExists(path tspath.RootedDirectoryPath) bool { + return h.program.Host().FS().DirectoryExists(path) +} + +func (h *fuzzLSHost) FileExists(path tspath.RootedFilePath) bool { + return h.program.Host().FS().FileExists(path) +} diff --git a/tsc/internal/testutil/harnessutil/harnessutil.go b/tsc/internal/testutil/harnessutil/harnessutil.go index 97055cb812622..2a155be6a9796 100644 --- a/tsc/internal/testutil/harnessutil/harnessutil.go +++ b/tsc/internal/testutil/harnessutil/harnessutil.go @@ -18,6 +18,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/bundled" + "github.com/microsoft/TypeScript/tsc/internal/checker" "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/compiler" "github.com/microsoft/TypeScript/tsc/internal/contentmapper" @@ -76,6 +77,7 @@ type HarnessOptions struct { ReportDiagnostics bool CaptureSuggestions bool TypescriptVersion string + CheckOrder string } func CompileFiles( @@ -226,6 +228,7 @@ func CompileFilesEx( result := compileFilesWithHost(t, host, config, harnessOptions) result.Symlinks = symlinks result.Trace = host.tracer.String() + fuzzCheckOrder(t, host, config, harnessOptions) result.Repeat = func(testConfig TestConfiguration) *CompilationResult { newHarnessOptions := *harnessOptions newCompilerOptions := compilerOptions.Clone() @@ -362,6 +365,32 @@ var harnessCommandLineOptions = []*tsoptions.CommandLineOption{ Name: "captureSuggestions", Kind: tsoptions.CommandLineOptionTypeBoolean, }, + // Changes the order in which the checker is queried; see checkOrders + { + Name: "checkOrder", + Kind: tsoptions.CommandLineOptionTypeString, + }, +} + +// Checker results should not depend on the order in which files and +// locations are queried. These orders let tests demonstrate that. Each +// applies to both checking and emit, which queries the checker too. +var checkOrders = []string{ + // Check and emit all files in program order. + "default", + // Check and emit files one at a time in reverse program order. + "reverse", + // Check and emit each file with a fresh program that has checked + // nothing else. + "isolated", + // Before checking or emitting, ask for the type, symbol, contextual + // type and resolved signature of every expression and name in each + // file, innermost and last first, as an editor might. + "typesfirst", + // Before checking or emitting, make the requests an editor makes of + // each file: signature help at every argument, its inlay hints, then + // hover over every name, innermost and last first. + "editorfirst", } func getHarnessOption(name string) *tsoptions.CommandLineOption { @@ -407,6 +436,12 @@ func parseHarnessOption(t *testing.T, key string, value any, harnessOptions *Har harnessOptions.CaptureSuggestions = value.(bool) case "typescriptVersion": harnessOptions.TypescriptVersion = value.(string) + case "checkOrder": + order := strings.ToLower(value.(string)) + if !slices.Contains(checkOrders, order) { + t.Fatalf("Unknown check order '%s'.", value) + } + harnessOptions.CheckOrder = order default: t.Fatalf("Unknown harness option '%s'.", key) } @@ -645,8 +680,7 @@ func compileFilesWithHost( preErrors = append(preErrors, preProgram.GetConfigFileParsingDiagnostics()...) preErrors = append(preErrors, preProgram.GetProgramDiagnostics()...) preErrors = append(preErrors, preProgram.GetSyntacticDiagnostics(ctx, nil)...) - preErrors = append(preErrors, preProgram.GetSemanticDiagnostics(ctx, nil)...) - preErrors = append(preErrors, preProgram.GetGlobalDiagnostics(ctx)...) + preErrors = append(preErrors, getCheckerDiagnostics(t, ctx, host, preConfig, preProgram, harnessOptions.CheckOrder)...) if harnessOptions.CaptureSuggestions { preErrors = append(preErrors, preProgram.GetSuggestionDiagnostics(ctx, nil)...) } @@ -656,13 +690,12 @@ func compileFilesWithHost( preErrors = compiler.SortAndDeduplicateDiagnostics(preErrors) postProgram := createProgram(t, host, config) - emitResult := postProgram.Emit(ctx, compiler.EmitOptions{}) + emitResult := emitInOrder(t, ctx, host, config, postProgram, harnessOptions.CheckOrder) var postErrors []*ast.Diagnostic postErrors = append(postErrors, postProgram.GetConfigFileParsingDiagnostics()...) postErrors = append(postErrors, postProgram.GetProgramDiagnostics()...) postErrors = append(postErrors, postProgram.GetSyntacticDiagnostics(ctx, nil)...) - postErrors = append(postErrors, postProgram.GetSemanticDiagnostics(ctx, nil)...) - postErrors = append(postErrors, postProgram.GetGlobalDiagnostics(ctx)...) + postErrors = append(postErrors, getCheckerDiagnostics(t, ctx, host, config, postProgram, harnessOptions.CheckOrder)...) if postProgram.Options().GetEmitDeclarations() { postErrors = append(postErrors, postProgram.GetDeclarationDiagnostics(ctx, nil)...) } @@ -699,9 +732,150 @@ func compileFilesWithHost( errors = append(errors, diag) } + assertCheckersAtRest(postProgram.Program()) return newCompilationResult(host, harnessOptions.CurrentDirectory, config.CompilerOptions(), postProgram, emitResult, errors, harnessOptions) } +// getCheckerDiagnostics returns the semantic and global diagnostics of +// program, querying the checker in the given order. +func getCheckerDiagnostics(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, program compiler.ProgramLike, order string) []*ast.Diagnostic { + var files []*ast.SourceFile + for _, file := range program.GetSourceFiles() { + if !program.Program().SkipTypeChecking(file, false) { + files = append(files, file) + } + } + var result []*ast.Diagnostic + switch order { + case "", "default": + result = append(result, program.GetSemanticDiagnostics(ctx, nil)...) + result = append(result, program.GetGlobalDiagnostics(ctx)...) + case "reverse": + for _, file := range slices.Backward(files) { + result = append(result, program.GetSemanticDiagnostics(ctx, file)...) + } + result = append(result, program.GetGlobalDiagnostics(ctx)...) + case "isolated": + for _, file := range files { + isolated := createProgram(t, host, config) + isolatedFile := isolated.GetSourceFile(file.FileName()) + result = append(result, isolated.GetSemanticDiagnostics(ctx, isolatedFile)...) + result = append(result, isolated.GetGlobalDiagnostics(ctx)...) + } + case "typesfirst": + for _, file := range slices.Backward(files) { + c, done := program.Program().GetTypeCheckerForFile(ctx, file) + queryNodes(c, file) + done() + } + result = append(result, program.GetSemanticDiagnostics(ctx, nil)...) + result = append(result, program.GetGlobalDiagnostics(ctx)...) + case "editorfirst": + makeEditorRequests(ctx, program, files) + result = append(result, program.GetSemanticDiagnostics(ctx, nil)...) + result = append(result, program.GetGlobalDiagnostics(ctx)...) + default: + panic("unknown check order " + order) + } + return compiler.SortAndDeduplicateDiagnostics(result) +} + +// emitInOrder emits program, querying the checker in the given order: each +// file emitted separately, in reverse or in a program of its own, or after +// querying every node of every file in reverse. +func emitInOrder(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, program compiler.ProgramLike, order string) *compiler.EmitResult { + options := program.Options() + if order == "" || order == "default" || options.OutFile != "" || options.NoEmitOnError.IsTrue() { + // Emitting files separately would change what a bundle or an emit + // blocked by errors contains. + return program.Emit(ctx, compiler.EmitOptions{}) + } + files := program.GetSourceFiles() + if order == "typesfirst" { + for _, file := range slices.Backward(files) { + if program.Program().SkipTypeChecking(file, false) { + continue + } + c, done := program.Program().GetTypeCheckerForFile(ctx, file) + queryNodes(c, file) + done() + } + return program.Emit(ctx, compiler.EmitOptions{}) + } + if order == "editorfirst" { + makeEditorRequests(ctx, program, core.Filter(files, func(file *ast.SourceFile) bool { + return !program.Program().SkipTypeChecking(file, false) + })) + return program.Emit(ctx, compiler.EmitOptions{}) + } + result := &compiler.EmitResult{} + emitFile := func(p compiler.ProgramLike, file *ast.SourceFile) { + r := p.Emit(ctx, compiler.EmitOptions{TargetSourceFiles: []*ast.SourceFile{file}}) + result.EmitSkipped = result.EmitSkipped || r.EmitSkipped + result.Diagnostics = append(result.Diagnostics, r.Diagnostics...) + result.EmittedFiles = append(result.EmittedFiles, r.EmittedFiles...) + result.SourceMaps = append(result.SourceMaps, r.SourceMaps...) + } + switch order { + case "reverse": + for _, file := range slices.Backward(files) { + emitFile(program, file) + } + case "isolated": + for _, file := range files { + isolated := createProgram(t, host, config) + emitFile(isolated, isolated.GetSourceFile(file.FileName())) + } + default: + panic("unknown check order " + order) + } + result.Diagnostics = compiler.SortAndDeduplicateDiagnostics(result.Diagnostics) + return result +} + +func queryNodes(c *checker.Checker, file *ast.SourceFile) { + var nodes []*ast.Node + var visit func(n *ast.Node) bool + visit = func(n *ast.Node) bool { + if n.Flags&ast.NodeFlagsReparsed == 0 { + nodes = append(nodes, n) + } + n.ForEachChild(visit) + return false + } + file.AsNode().ForEachChild(visit) + for _, n := range slices.Backward(nodes) { + if ast.IsExpressionNode(n) || n.Kind == ast.KindIdentifier || ast.IsDeclarationName(n) { + for _, kind := range fuzzNodeQueryKinds(n) { + fuzzQueryResult(c, n, kind) + } + } + } +} + +// makeEditorRequests asks for signature help at every argument of each of +// files, its inlay hints, then hover over every name, innermost and last +// first. +func makeEditorRequests(ctx context.Context, program compiler.ProgramLike, files []*ast.SourceFile) { + lang := fuzzLanguageService(program.Program()) + for _, file := range slices.Backward(files) { + nodes := core.Filter(fuzzNodes(file), func(n *ast.Node) bool { + return !ast.PositionIsSynthesized(n.Pos()) + }) + for _, n := range slices.Backward(nodes) { + if parent := n.Parent; parent != nil && ast.IsCallOrNewExpression(parent) && n != parent.Expression() { + fuzzLSResult(ctx, lang, file, n, fuzzQuerySignatureHelp) + } + } + fuzzLSResult(ctx, lang, file, nil, fuzzQueryInlayHints) + for _, n := range slices.Backward(nodes) { + if ast.IsIdentifier(n) { + fuzzLSResult(ctx, lang, file, n, fuzzQueryHover) + } + } + } +} + type CompilationResult struct { Diagnostics []*ast.Diagnostic Result *compiler.EmitResult @@ -973,6 +1147,11 @@ func getTestBuildInfoReader(host compiler.CompilerHost) *testBuildInfoReader { } func createProgram(t *testing.T, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine) compiler.ProgramLike { + t.Helper() + return createProgramWithCheckers(t, host, config, nil) +} + +func createProgramWithCheckers(t *testing.T, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, assignCheckers func([]*ast.SourceFile) []int) compiler.ProgramLike { t.Helper() var singleThreaded core.Tristate if testutil.TestProgramIsSingleThreaded() { @@ -983,6 +1162,7 @@ func createProgram(t *testing.T, host compiler.CompilerHost, config *tsoptions.P Config: config, Host: host, SingleThreaded: singleThreaded, + AssignCheckers: assignCheckers, } program, err := compiler.NewProgram(t.Context(), programOptions) if err != nil { @@ -1165,6 +1345,9 @@ func getValueOfOptionString(t *testing.T, option string, value string) tsoptions func tryGetValueOfOptionString(option string, value string) (tsoptions.CompilerOptionsValue, bool) { optionDecl := getCommandLineOption(option) + if optionDecl == nil { + optionDecl = getHarnessOption(option) + } if optionDecl == nil { return nil, false } diff --git a/tsc/internal/transformers/tstransforms/importelision_test.go b/tsc/internal/transformers/tstransforms/importelision_test.go index f2f2ca4014044..350e2d65c98a3 100644 --- a/tsc/internal/transformers/tstransforms/importelision_test.go +++ b/tsc/internal/transformers/tstransforms/importelision_test.go @@ -36,6 +36,10 @@ func (p *fakeProgram) GetRedirectForResolution(file ast.HasFileName) *tsoptions. } // SourceFileMayBeEmitted implements checker.Program. +func (p *fakeProgram) SkipTypeChecking(sourceFile *ast.SourceFile, ignoreNoCheck bool) bool { + return false +} + func (p *fakeProgram) SourceFileMayBeEmitted(sourceFile *ast.SourceFile, forceDtsEmit bool) bool { panic("unimplemented") } diff --git a/tsc/internal/tsoptions/declarations_generated.go b/tsc/internal/tsoptions/declarations_generated.go index 6720def45af11..56e6f2a6c95ab 100644 --- a/tsc/internal/tsoptions/declarations_generated.go +++ b/tsc/internal/tsoptions/declarations_generated.go @@ -231,7 +231,7 @@ var commonOptionsWithBuild = []*CommandLineOption{ Kind: CommandLineOptionTypeNumber, Category: diagnostics.Command_line_Options, Description: diagnostics.Set_the_number_of_checkers_per_project, - DefaultValueDescription: diagnostics.X_4_unless_singleThreaded_is_passed, + DefaultValueDescription: diagnostics.Based_on_the_available_CPUs_and_the_size_of_the_project_unless_singleThreaded_is_passed, minValue: 1, }, { diff --git a/tsc/testdata/baselines/reference/compiler/argumentsReferenceInObjectLiteral_Js(alwaysstrict=true).types b/tsc/testdata/baselines/reference/compiler/argumentsReferenceInObjectLiteral_Js(alwaysstrict=true).types index ede507ae296eb..c29b02354c562 100644 --- a/tsc/testdata/baselines/reference/compiler/argumentsReferenceInObjectLiteral_Js(alwaysstrict=true).types +++ b/tsc/testdata/baselines/reference/compiler/argumentsReferenceInObjectLiteral_Js(alwaysstrict=true).types @@ -2,8 +2,8 @@ === /a.js === const a = () => { ->a : () => { arguments: undefined[]; } ->() => { return { arguments: [], };} : () => { arguments: undefined[]; } +>a : () => { arguments: any[]; } +>() => { return { arguments: [], };} : () => { arguments: any[]; } return { >{ arguments: [], } : { arguments: undefined[]; } diff --git a/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=default).js new file mode 100644 index 0000000000000..9375a099f5c6f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=default).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts] //// + +//// [assertionOperandInLoopAssertionCallNoHang.ts] +declare function assertEqual(actual: unknown, expected: T): asserts actual; +declare class C {} +declare function on(cb: (e: undefined) => void): void; +declare const data: []; + +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e as C, data); + } +}); + + +//// [assertionOperandInLoopAssertionCallNoHang.js] +"use strict"; +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e, data); + } +}); diff --git a/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=isolated).js new file mode 100644 index 0000000000000..9375a099f5c6f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=isolated).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts] //// + +//// [assertionOperandInLoopAssertionCallNoHang.ts] +declare function assertEqual(actual: unknown, expected: T): asserts actual; +declare class C {} +declare function on(cb: (e: undefined) => void): void; +declare const data: []; + +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e as C, data); + } +}); + + +//// [assertionOperandInLoopAssertionCallNoHang.js] +"use strict"; +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e, data); + } +}); diff --git a/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=reverse).js new file mode 100644 index 0000000000000..9375a099f5c6f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=reverse).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts] //// + +//// [assertionOperandInLoopAssertionCallNoHang.ts] +declare function assertEqual(actual: unknown, expected: T): asserts actual; +declare class C {} +declare function on(cb: (e: undefined) => void): void; +declare const data: []; + +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e as C, data); + } +}); + + +//// [assertionOperandInLoopAssertionCallNoHang.js] +"use strict"; +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e, data); + } +}); diff --git a/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=typesfirst).js new file mode 100644 index 0000000000000..9375a099f5c6f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=typesfirst).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts] //// + +//// [assertionOperandInLoopAssertionCallNoHang.ts] +declare function assertEqual(actual: unknown, expected: T): asserts actual; +declare class C {} +declare function on(cb: (e: undefined) => void): void; +declare const data: []; + +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e as C, data); + } +}); + + +//// [assertionOperandInLoopAssertionCallNoHang.js] +"use strict"; +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e, data); + } +}); diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..a56b4e4614407 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,16 @@ +baseConstraintDepthCheckOrder.ts(7,7): error TS2339: Property 'length' does not exist on type 'T0'. + + +==== baseConstraintDepthCheckOrder.ts (1 errors) ==== + // The base constraint of 'T0' is 60 type parameters deep and gives up after + // 50, while that of 'T20' is found 40 deep. Neither may depend on which was + // computed first: computing 'T0' first must not leave 'T20' without its + // constraint, and computing 'T20' first must not let 'T0' reuse it. + + function f(x: T0, y: T20) { + x.length; + ~~~~~~ +!!! error TS2339: Property 'length' does not exist on type 'T0'. + y.length; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..bea0526aba4e1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols @@ -0,0 +1,143 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : Symbol(f, Decl(baseConstraintDepthCheckOrder.ts, 0, 0)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) + + x.length; +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) + + y.length; +>y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..e36c86990b2ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : (x: T0, y: T20) => void +>x : T0 +>y : T20 + + x.length; +>x.length : any +>x : T0 +>length : any + + y.length; +>y.length : number +>y : T20 +>length : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..a56b4e4614407 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +baseConstraintDepthCheckOrder.ts(7,7): error TS2339: Property 'length' does not exist on type 'T0'. + + +==== baseConstraintDepthCheckOrder.ts (1 errors) ==== + // The base constraint of 'T0' is 60 type parameters deep and gives up after + // 50, while that of 'T20' is found 40 deep. Neither may depend on which was + // computed first: computing 'T0' first must not leave 'T20' without its + // constraint, and computing 'T20' first must not let 'T0' reuse it. + + function f(x: T0, y: T20) { + x.length; + ~~~~~~ +!!! error TS2339: Property 'length' does not exist on type 'T0'. + y.length; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..bea0526aba4e1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,143 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : Symbol(f, Decl(baseConstraintDepthCheckOrder.ts, 0, 0)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) + + x.length; +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) + + y.length; +>y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..e36c86990b2ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : (x: T0, y: T20) => void +>x : T0 +>y : T20 + + x.length; +>x.length : any +>x : T0 +>length : any + + y.length; +>y.length : number +>y : T20 +>length : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).errors.txt new file mode 100644 index 0000000000000..5a959d4e04b62 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).errors.txt @@ -0,0 +1,69 @@ +badExport.ts(1,10): error TS2304: Cannot find name 'foo'. +badExport.ts(1,17): error TS1003: Identifier expected. +badExport.ts(1,20): error TS1128: Declaration or statement expected. +badExport2.ts(1,10): error TS1003: Identifier expected. +badExport2.ts(1,16): error TS2304: Cannot find name 'foo'. +badExport2.ts(1,20): error TS1128: Declaration or statement expected. +badImport.ts(1,10): error TS1003: Identifier expected. +badImport.ts(1,10): error TS1141: String literal expected. +badImport.ts(1,20): error TS1128: Declaration or statement expected. +badImport.ts(1,22): error TS1434: Unexpected keyword or identifier. +badImport.ts(1,22): error TS2304: Cannot find name 'from'. +badImport2.ts(1,17): error TS1003: Identifier expected. +badImport2.ts(1,17): error TS1141: String literal expected. +badImport2.ts(1,20): error TS1128: Declaration or statement expected. +badImport2.ts(1,22): error TS1434: Unexpected keyword or identifier. +badImport2.ts(1,22): error TS2304: Cannot find name 'from'. + + +==== foo.ts (0 errors) ==== + const foo = 0n; + export { foo as "0n" }; + +==== correctUse.ts (0 errors) ==== + import { "0n" as foo } from "./foo"; + export { foo as "0n" }; + +==== badImport.ts (5 errors) ==== + import { 0n as foo } from "./foo"; + ~~ +!!! error TS1003: Identifier expected. + ~~~~~~~~~ +!!! error TS1141: String literal expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~~~~ +!!! error TS1434: Unexpected keyword or identifier. + ~~~~ +!!! error TS2304: Cannot find name 'from'. + +==== badImport2.ts (5 errors) ==== + import { foo as 0n } from "./foo"; + ~~ +!!! error TS1003: Identifier expected. + ~~ +!!! error TS1141: String literal expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~~~~ +!!! error TS1434: Unexpected keyword or identifier. + ~~~~ +!!! error TS2304: Cannot find name 'from'. + +==== badExport.ts (3 errors) ==== + export { foo as 0n }; + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1128: Declaration or statement expected. + +==== badExport2.ts (3 errors) ==== + export { 0n as foo }; + ~~ +!!! error TS1003: Identifier expected. + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~ +!!! error TS1128: Declaration or statement expected. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).js new file mode 100644 index 0000000000000..139c1991c8c3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).js @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +//// [foo.ts] +const foo = 0n; +export { foo as "0n" }; + +//// [correctUse.ts] +import { "0n" as foo } from "./foo"; +export { foo as "0n" }; + +//// [badImport.ts] +import { 0n as foo } from "./foo"; + +//// [badImport2.ts] +import { foo as 0n } from "./foo"; + +//// [badExport.ts] +export { foo as 0n }; + +//// [badExport2.ts] +export { 0n as foo }; + +//// [foo.js] +const foo = 0n; +export { foo as "0n" }; +//// [correctUse.js] +import { "0n" as foo } from "./foo"; +export { foo as "0n" }; +//// [badImport.js] +from; +"./foo"; +export {}; +//// [badImport2.js] +from; +"./foo"; +export {}; +//// [badExport.js] +export { foo as }; +0n; +; +//// [badExport2.js] +0n; +; +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).symbols new file mode 100644 index 0000000000000..8ef83a9eaec97 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +=== foo.ts === +const foo = 0n; +>foo : Symbol(foo, Decl(foo.ts, 0, 5)) + +export { foo as "0n" }; +>foo : Symbol(foo, Decl(foo.ts, 0, 5)) +>"0n" : Symbol("0n", Decl(foo.ts, 1, 8)) + +=== correctUse.ts === +import { "0n" as foo } from "./foo"; +>foo : Symbol(foo, Decl(correctUse.ts, 0, 8)) + +export { foo as "0n" }; +>foo : Symbol(foo, Decl(correctUse.ts, 0, 8)) +>"0n" : Symbol("0n", Decl(correctUse.ts, 1, 8)) + +=== badImport.ts === +import { 0n as foo } from "./foo"; +>foo : Symbol(foo) + +=== badImport2.ts === +import { foo as 0n } from "./foo"; +> : Symbol((Missing), Decl(badImport2.ts, 0, 8)) + +=== badExport.ts === +export { foo as 0n }; +> : Symbol((Missing), Decl(badExport.ts, 0, 8)) + +=== badExport2.ts === +export { 0n as foo }; +>foo : Symbol(foo) + diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).types new file mode 100644 index 0000000000000..c3f2d2ceb5859 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +=== foo.ts === +const foo = 0n; +>foo : 0n +>0n : 0n + +export { foo as "0n" }; +>foo : 0n +>"0n" : 0n + +=== correctUse.ts === +import { "0n" as foo } from "./foo"; +>foo : 0n + +export { foo as "0n" }; +>foo : 0n +>"0n" : 0n + +=== badImport.ts === +import { 0n as foo } from "./foo"; +>0n as foo : foo +>0n : 0n +>from : any +>"./foo" : "./foo" + +=== badImport2.ts === +import { foo as 0n } from "./foo"; +>foo : any +> : any +>from : any +>"./foo" : "./foo" + +=== badExport.ts === +export { foo as 0n }; +>foo : any +> : any +>0n : 0n + +=== badExport2.ts === +export { 0n as foo }; +>0n as foo : foo +>0n : 0n + diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..5a959d4e04b62 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt @@ -0,0 +1,69 @@ +badExport.ts(1,10): error TS2304: Cannot find name 'foo'. +badExport.ts(1,17): error TS1003: Identifier expected. +badExport.ts(1,20): error TS1128: Declaration or statement expected. +badExport2.ts(1,10): error TS1003: Identifier expected. +badExport2.ts(1,16): error TS2304: Cannot find name 'foo'. +badExport2.ts(1,20): error TS1128: Declaration or statement expected. +badImport.ts(1,10): error TS1003: Identifier expected. +badImport.ts(1,10): error TS1141: String literal expected. +badImport.ts(1,20): error TS1128: Declaration or statement expected. +badImport.ts(1,22): error TS1434: Unexpected keyword or identifier. +badImport.ts(1,22): error TS2304: Cannot find name 'from'. +badImport2.ts(1,17): error TS1003: Identifier expected. +badImport2.ts(1,17): error TS1141: String literal expected. +badImport2.ts(1,20): error TS1128: Declaration or statement expected. +badImport2.ts(1,22): error TS1434: Unexpected keyword or identifier. +badImport2.ts(1,22): error TS2304: Cannot find name 'from'. + + +==== foo.ts (0 errors) ==== + const foo = 0n; + export { foo as "0n" }; + +==== correctUse.ts (0 errors) ==== + import { "0n" as foo } from "./foo"; + export { foo as "0n" }; + +==== badImport.ts (5 errors) ==== + import { 0n as foo } from "./foo"; + ~~ +!!! error TS1003: Identifier expected. + ~~~~~~~~~ +!!! error TS1141: String literal expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~~~~ +!!! error TS1434: Unexpected keyword or identifier. + ~~~~ +!!! error TS2304: Cannot find name 'from'. + +==== badImport2.ts (5 errors) ==== + import { foo as 0n } from "./foo"; + ~~ +!!! error TS1003: Identifier expected. + ~~ +!!! error TS1141: String literal expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~~~~ +!!! error TS1434: Unexpected keyword or identifier. + ~~~~ +!!! error TS2304: Cannot find name 'from'. + +==== badExport.ts (3 errors) ==== + export { foo as 0n }; + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1128: Declaration or statement expected. + +==== badExport2.ts (3 errors) ==== + export { 0n as foo }; + ~~ +!!! error TS1003: Identifier expected. + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~ +!!! error TS1128: Declaration or statement expected. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).js new file mode 100644 index 0000000000000..139c1991c8c3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).js @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +//// [foo.ts] +const foo = 0n; +export { foo as "0n" }; + +//// [correctUse.ts] +import { "0n" as foo } from "./foo"; +export { foo as "0n" }; + +//// [badImport.ts] +import { 0n as foo } from "./foo"; + +//// [badImport2.ts] +import { foo as 0n } from "./foo"; + +//// [badExport.ts] +export { foo as 0n }; + +//// [badExport2.ts] +export { 0n as foo }; + +//// [foo.js] +const foo = 0n; +export { foo as "0n" }; +//// [correctUse.js] +import { "0n" as foo } from "./foo"; +export { foo as "0n" }; +//// [badImport.js] +from; +"./foo"; +export {}; +//// [badImport2.js] +from; +"./foo"; +export {}; +//// [badExport.js] +export { foo as }; +0n; +; +//// [badExport2.js] +0n; +; +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..8ef83a9eaec97 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +=== foo.ts === +const foo = 0n; +>foo : Symbol(foo, Decl(foo.ts, 0, 5)) + +export { foo as "0n" }; +>foo : Symbol(foo, Decl(foo.ts, 0, 5)) +>"0n" : Symbol("0n", Decl(foo.ts, 1, 8)) + +=== correctUse.ts === +import { "0n" as foo } from "./foo"; +>foo : Symbol(foo, Decl(correctUse.ts, 0, 8)) + +export { foo as "0n" }; +>foo : Symbol(foo, Decl(correctUse.ts, 0, 8)) +>"0n" : Symbol("0n", Decl(correctUse.ts, 1, 8)) + +=== badImport.ts === +import { 0n as foo } from "./foo"; +>foo : Symbol(foo) + +=== badImport2.ts === +import { foo as 0n } from "./foo"; +> : Symbol((Missing), Decl(badImport2.ts, 0, 8)) + +=== badExport.ts === +export { foo as 0n }; +> : Symbol((Missing), Decl(badExport.ts, 0, 8)) + +=== badExport2.ts === +export { 0n as foo }; +>foo : Symbol(foo) + diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).types new file mode 100644 index 0000000000000..c3f2d2ceb5859 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +=== foo.ts === +const foo = 0n; +>foo : 0n +>0n : 0n + +export { foo as "0n" }; +>foo : 0n +>"0n" : 0n + +=== correctUse.ts === +import { "0n" as foo } from "./foo"; +>foo : 0n + +export { foo as "0n" }; +>foo : 0n +>"0n" : 0n + +=== badImport.ts === +import { 0n as foo } from "./foo"; +>0n as foo : foo +>0n : 0n +>from : any +>"./foo" : "./foo" + +=== badImport2.ts === +import { foo as 0n } from "./foo"; +>foo : any +> : any +>from : any +>"./foo" : "./foo" + +=== badExport.ts === +export { foo as 0n }; +>foo : any +> : any +>0n : 0n + +=== badExport2.ts === +export { 0n as foo }; +>0n as foo : foo +>0n : 0n + diff --git a/tsc/testdata/baselines/reference/compiler/blockScopedBindingUsedBeforeDef.errors.txt b/tsc/testdata/baselines/reference/compiler/blockScopedBindingUsedBeforeDef.errors.txt index 1be1808a2e8cc..4eb1fec342c35 100644 --- a/tsc/testdata/baselines/reference/compiler/blockScopedBindingUsedBeforeDef.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/blockScopedBindingUsedBeforeDef.errors.txt @@ -1,9 +1,9 @@ blockScopedBindingUsedBeforeDef.ts(2,12): error TS2448: Block-scoped variable 'a' used before its declaration. -blockScopedBindingUsedBeforeDef.ts(2,12): error TS2538: Type '{}' cannot be used as an index type. +blockScopedBindingUsedBeforeDef.ts(2,12): error TS2538: Type 'any' cannot be used as an index type. blockScopedBindingUsedBeforeDef.ts(5,12): error TS2448: Block-scoped variable 'a' used before its declaration. -blockScopedBindingUsedBeforeDef.ts(5,12): error TS2538: Type '{}' cannot be used as an index type. +blockScopedBindingUsedBeforeDef.ts(5,12): error TS2538: Type 'any' cannot be used as an index type. blockScopedBindingUsedBeforeDef.ts(8,7): error TS2448: Block-scoped variable 'b' used before its declaration. -blockScopedBindingUsedBeforeDef.ts(8,7): error TS2538: Type '{}' cannot be used as an index type. +blockScopedBindingUsedBeforeDef.ts(8,7): error TS2538: Type 'any' cannot be used as an index type. ==== blockScopedBindingUsedBeforeDef.ts (6 errors) ==== @@ -13,7 +13,7 @@ blockScopedBindingUsedBeforeDef.ts(8,7): error TS2538: Type '{}' cannot be used !!! error TS2448: Block-scoped variable 'a' used before its declaration. !!! related TS2728 blockScopedBindingUsedBeforeDef.ts:2:16: 'a' is declared here. ~ -!!! error TS2538: Type '{}' cannot be used as an index type. +!!! error TS2538: Type 'any' cannot be used as an index type. // 2: for (let {[a]: a} = { }; false; ) continue; @@ -21,7 +21,7 @@ blockScopedBindingUsedBeforeDef.ts(8,7): error TS2538: Type '{}' cannot be used !!! error TS2448: Block-scoped variable 'a' used before its declaration. !!! related TS2728 blockScopedBindingUsedBeforeDef.ts:5:16: 'a' is declared here. ~ -!!! error TS2538: Type '{}' cannot be used as an index type. +!!! error TS2538: Type 'any' cannot be used as an index type. // 3: let {[b]: b} = { }; @@ -29,4 +29,4 @@ blockScopedBindingUsedBeforeDef.ts(8,7): error TS2538: Type '{}' cannot be used !!! error TS2448: Block-scoped variable 'b' used before its declaration. !!! related TS2728 blockScopedBindingUsedBeforeDef.ts:8:11: 'b' is declared here. ~ -!!! error TS2538: Type '{}' cannot be used as an index type. \ No newline at end of file +!!! error TS2538: Type 'any' cannot be used as an index type. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.symbols b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.symbols new file mode 100644 index 0000000000000..12f0269e1ddb6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.symbols @@ -0,0 +1,424 @@ +//// [tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts] //// + +=== boundedRecursiveTypeInferredThroughClosure.ts === +// The recursion of InferData and UnpackKeyValue is bounded by Next, so +// inferring it through a closure must not report it as infinite. + +type Prettify = { [K in keyof T]: T[K] } & {}; +>Prettify : Symbol(Prettify, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 0, 0)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 14)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 22)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 14)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 14)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 22)) + +type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; +>ExtractUndefined : Symbol(ExtractUndefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 49)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 30)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 30)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 30)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) + +type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; +>ExtractDefined : Symbol(ExtractDefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 91)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 28)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 28)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 28)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) + +type Next = [1, 2, 3, 4, 5, 6]; +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) + +type JSONPrimitives = string | number | bigint | boolean | null | undefined; +>JSONPrimitives : Symbol(JSONPrimitives, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 6, 31)) + +type JSONValues = JSONPrimitives | CanBeSerialized; +>JSONValues : Symbol(JSONValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 7, 76)) +>JSONPrimitives : Symbol(JSONPrimitives, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 6, 31)) +>CanBeSerialized : Symbol(CanBeSerialized, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 8, 56)) + +type CanBeSerialized = { +>CanBeSerialized : Symbol(CanBeSerialized, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 8, 56)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 9, 21)) +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) + + toJSON(): T; +>toJSON : Symbol(toJSON, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 9, 49)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 9, 21)) + +}; +type JSONDataTypes = JSONValues | JSONDataTypes[] | { +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) +>JSONValues : Symbol(JSONValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 7, 76)) +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) + + [key: string]: JSONDataTypes; +>key : Symbol(key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 13, 5)) +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) + +}; +type SerializeJSONObject = { +>SerializeJSONObject : Symbol(SerializeJSONObject, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 14, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) + + [K in ExtractDefined]: SerializeJSONTypes; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 16, 5)) +>ExtractDefined : Symbol(ExtractDefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 91)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 16, 5)) + +} & { + [K in ExtractUndefined]?: SerializeJSONTypes; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 18, 5)) +>ExtractUndefined : Symbol(ExtractUndefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 49)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 18, 5)) + +}; +interface ExtendedJSONTypes { +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) +} +type NonAllowedJSTypes = Map | Set; +>NonAllowedJSTypes : Symbol(NonAllowedJSTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 21, 1)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) + +type ForcefullyAllowedTypes = { +>ForcefullyAllowedTypes : Symbol(ForcefullyAllowedTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 22, 50)) + + [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 24, 5)) +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 24, 5)) + +}[keyof ExtendedJSONTypes]; +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) + +type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; +>SerializeJSONOwnTypes : Symbol(SerializeJSONOwnTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 25, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>JSONPrimitives : Symbol(JSONPrimitives, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 6, 31)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>ForcefullyAllowedTypes : Symbol(ForcefullyAllowedTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 22, 50)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>NonAllowedJSTypes : Symbol(NonAllowedJSTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 21, 1)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>item : Symbol(item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 161)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>item : Symbol(item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 161)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>Prettify : Symbol(Prettify, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 0, 0)) +>SerializeJSONObject : Symbol(SerializeJSONObject, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 14, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) + +type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>ForcefullyAllowedTypes : Symbol(ForcefullyAllowedTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 22, 50)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>CanBeSerialized : Symbol(CanBeSerialized, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 8, 56)) +>A : Symbol(A, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 99)) +>SerializeJSONOwnTypes : Symbol(SerializeJSONOwnTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 25, 27)) +>A : Symbol(A, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 99)) +>SerializeJSONOwnTypes : Symbol(SerializeJSONOwnTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 25, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) + +interface ItemContract, MaxDepth extends Next[number], Variant extends string> { +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 23)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 63)) +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 94)) + + $type: 'item'; +>$type : Symbol(ItemContract.$type, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 120)) + + transformer: { +>transformer : Symbol(ItemContract.transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 29, 18)) + + new (...args: any[]): Transformer; +>args : Symbol(args, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 31, 13)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 23)) + + }; + maxDepth: MaxDepth; +>maxDepth : Symbol(ItemContract.maxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 32, 6)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 63)) + + variant: Variant; +>variant : Symbol(ItemContract.variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 33, 23)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 94)) +} +type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; +>UnpackKeyValue : Symbol(UnpackKeyValue, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 35, 1)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 45)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 70)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 190)) +>LocalMaxDepth : Symbol(LocalMaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 209)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 230)) +>InferData : Symbol(InferData, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 173)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 190)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 230)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 45)) +>LocalMaxDepth : Symbol(LocalMaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 209)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 45)) +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 70)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) + +type LimitDepth = [ +>LimitDepth : Symbol(LimitDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 397)) +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 20)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 27)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 52)) + + Value +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 20)) + +] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 20)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 27)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 52)) +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) + +type UnpackOptionalValues = { +>UnpackOptionalValues : Symbol(UnpackOptionalValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 39, 113)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 56)) + + [O in { +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 41, 5)) + + [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>LimitDepth : Symbol(LimitDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 397)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 56)) + + }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>UnpackKeyValue : Symbol(UnpackKeyValue, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 35, 1)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 41, 5)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 56)) + +}; +type UnpackRequiredValues = { +>UnpackRequiredValues : Symbol(UnpackRequiredValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 44, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 56)) + + [O in { +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 46, 5)) + + [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>LimitDepth : Symbol(LimitDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 397)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 56)) + + }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>UnpackKeyValue : Symbol(UnpackKeyValue, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 35, 1)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 46, 5)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 56)) + +}; +type SplitItm = [ +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 50, 14)) + + Extract>, +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 50, 14)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) + + Exclude> +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 50, 14)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) + +]; +type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; +>UnpackAsTopLevelItem : Symbol(UnpackAsTopLevelItem, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 53, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 26)) +>Wrapper : Symbol(Wrapper, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 28)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 26)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 95)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 119)) +>InferData : Symbol(InferData, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 173)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 95)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 119)) + +type UnpackValues = Prettify & UnpackOptionalValues>; +>UnpackValues : Symbol(UnpackValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 178)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 18)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 23)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 48)) +>Prettify : Symbol(Prettify, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 0, 0)) +>UnpackRequiredValues : Symbol(UnpackRequiredValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 44, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 18)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 23)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 48)) +>UnpackOptionalValues : Symbol(UnpackOptionalValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 39, 113)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 18)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 23)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 48)) + +type InferData = Transformer extends { +>InferData : Symbol(InferData, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 173)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 15)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 27)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 64)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 94)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 15)) + + [K in Variant]: (...args: any[]) => unknown; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 57, 5)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 27)) +>args : Symbol(args, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 57, 21)) + +} ? UnpackValues>, MaxDepth, Depth> : never; +>UnpackValues : Symbol(UnpackValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 178)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>ReturnType : Symbol(ReturnType, Decl(lib.es5.d.ts, --, --)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 15)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 27)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 64)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 94)) + +declare class Item, MaxDepth extends Next[number], Variant extends string> { +>Item : Symbol(Item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 58, 85)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 59)) +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 90)) + + transformer: { new (...args: any[]): Transformer }; +>transformer : Symbol(Item.transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 116)) +>args : Symbol(args, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 60, 21)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 19)) + + maxDepth: MaxDepth; +>maxDepth : Symbol(Item.maxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 60, 52)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 59)) + + variant: Variant; +>variant : Symbol(Item.variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 61, 20)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 90)) + + $type: 'item'; +>$type : Symbol(Item.$type, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 62, 18)) + + resolve(): Promise>; +>resolve : Symbol(Item.resolve, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 63, 15)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>UnpackAsTopLevelItem : Symbol(UnpackAsTopLevelItem, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 53, 2)) +} +type Ctor = { new (resource: any, ...rest: any[]): any }; +>Ctor : Symbol(Ctor, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 65, 1)) +>resource : Symbol(resource, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 19)) +>rest : Symbol(rest, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 33)) + +declare abstract class BaseTransformer { +>BaseTransformer : Symbol(BaseTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 57)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 39)) + + static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; +>transform : Symbol(BaseTransformer.transform, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 43)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) +>Ctor : Symbol(Ctor, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 65, 1)) +>this : Symbol(this, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 37)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) +>data : Symbol(data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 48)) +>ConstructorParameters : Symbol(ConstructorParameters, Decl(lib.es5.d.ts, --, --)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) +>Item : Symbol(Item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 58, 85)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) + + constructor(resource: T); +>resource : Symbol(resource, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 69, 13)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 39)) +} +class Size { +>Size : Symbol(Size, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 70, 1)) +} +class SizeTransformer extends BaseTransformer { +>SizeTransformer : Symbol(SizeTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 72, 1)) +>BaseTransformer : Symbol(BaseTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 57)) +>Size : Symbol(Size, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 70, 1)) + + toObject() { +>toObject : Symbol(SizeTransformer.toObject, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 73, 53)) + } +} +declare function once(value: T): T; +>once : Symbol(once, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 76, 1)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 22)) +>value : Symbol(value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 25)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 22)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 22)) + +once(() => SizeTransformer.transform(new Size())); +>once : Symbol(once, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 76, 1)) +>SizeTransformer.transform : Symbol(BaseTransformer.transform, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 43)) +>SizeTransformer : Symbol(SizeTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 72, 1)) +>transform : Symbol(BaseTransformer.transform, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 43)) +>Size : Symbol(Size, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 70, 1)) + diff --git a/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.types b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.types new file mode 100644 index 0000000000000..1f285bcdb698b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.types @@ -0,0 +1,186 @@ +//// [tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts] //// + +=== boundedRecursiveTypeInferredThroughClosure.ts === +// The recursion of InferData and UnpackKeyValue is bounded by Next, so +// inferring it through a closure must not report it as infinite. + +type Prettify = { [K in keyof T]: T[K] } & {}; +>Prettify : { [K in keyof T]: T[K]; } + +type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; +>ExtractUndefined : ExtractUndefined + +type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; +>ExtractDefined : ExtractDefined + +type Next = [1, 2, 3, 4, 5, 6]; +>Next : Next + +type JSONPrimitives = string | number | bigint | boolean | null | undefined; +>JSONPrimitives : JSONPrimitives + +type JSONValues = JSONPrimitives | CanBeSerialized; +>JSONValues : JSONValues + +type CanBeSerialized = { +>CanBeSerialized : CanBeSerialized + + toJSON(): T; +>toJSON : () => T + +}; +type JSONDataTypes = JSONValues | JSONDataTypes[] | { +>JSONDataTypes : JSONDataTypes + + [key: string]: JSONDataTypes; +>key : string + +}; +type SerializeJSONObject = { +>SerializeJSONObject : SerializeJSONObject + + [K in ExtractDefined]: SerializeJSONTypes; +} & { + [K in ExtractUndefined]?: SerializeJSONTypes; +}; +interface ExtendedJSONTypes { +} +type NonAllowedJSTypes = Map | Set; +>NonAllowedJSTypes : NonAllowedJSTypes + +type ForcefullyAllowedTypes = { +>ForcefullyAllowedTypes : never + + [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; +}[keyof ExtendedJSONTypes]; +type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; +>SerializeJSONOwnTypes : SerializeJSONOwnTypes + +type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; +>SerializeJSONTypes : SerializeJSONTypes + +interface ItemContract, MaxDepth extends Next[number], Variant extends string> { + $type: 'item'; +>$type : "item" + + transformer: { +>transformer : new (...args: any[]) => Transformer + + new (...args: any[]): Transformer; +>args : any[] + + }; + maxDepth: MaxDepth; +>maxDepth : MaxDepth + + variant: Variant; +>variant : Variant +} +type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; +>UnpackKeyValue : UnpackKeyValue +>-1 : -1 +>1 : 1 + +type LimitDepth = [ +>LimitDepth : LimitDepth + + Value +] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; +type UnpackOptionalValues = { +>UnpackOptionalValues : UnpackOptionalValues + + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; + }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; +}; +type UnpackRequiredValues = { +>UnpackRequiredValues : UnpackRequiredValues + + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; + }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; +}; +type SplitItm = [ +>SplitItm : SplitItm + + Extract>, + Exclude> +]; +type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; +>UnpackAsTopLevelItem : UnpackAsTopLevelItem +>-1 : -1 +>1 : 1 + +type UnpackValues = Prettify & UnpackOptionalValues>; +>UnpackValues : UnpackRequiredValues & UnpackOptionalValues extends infer T ? { [K in keyof T]: T[K]; } : never + +type InferData = Transformer extends { +>InferData : InferData +>-1 : -1 +>1 : 1 + + [K in Variant]: (...args: any[]) => unknown; +>args : any[] + +} ? UnpackValues>, MaxDepth, Depth> : never; +declare class Item, MaxDepth extends Next[number], Variant extends string> { +>Item : Item + + transformer: { new (...args: any[]): Transformer }; +>transformer : new (...args: any[]) => Transformer +>args : any[] + + maxDepth: MaxDepth; +>maxDepth : MaxDepth + + variant: Variant; +>variant : Variant + + $type: 'item'; +>$type : "item" + + resolve(): Promise>; +>resolve : () => Promise> +} +type Ctor = { new (resource: any, ...rest: any[]): any }; +>Ctor : Ctor +>resource : any +>rest : any[] + +declare abstract class BaseTransformer { +>BaseTransformer : BaseTransformer + + static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; +>transform : (this: Self, data: ConstructorParameters[0]) => Item, 1, 'toObject'> +>this : Self +>data : ConstructorParameters[0] + + constructor(resource: T); +>resource : T +} +class Size { +>Size : Size +} +class SizeTransformer extends BaseTransformer { +>SizeTransformer : SizeTransformer +>BaseTransformer : BaseTransformer + + toObject() { +>toObject : () => void + } +} +declare function once(value: T): T; +>once : (value: T) => T +>value : T + +once(() => SizeTransformer.transform(new Size())); +>once(() => SizeTransformer.transform(new Size())) : () => Item +>once : (value: T) => T +>() => SizeTransformer.transform(new Size()) : () => Item +>SizeTransformer.transform(new Size()) : Item +>SizeTransformer.transform : (this: Self, data: ConstructorParameters[0]) => Item, 1, 'toObject'> +>SizeTransformer : typeof SizeTransformer +>transform : (this: Self, data: ConstructorParameters[0]) => Item, 1, 'toObject'> +>new Size() : Size +>Size : typeof Size + diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).errors.txt new file mode 100644 index 0000000000000..fa22beceb33e2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).errors.txt @@ -0,0 +1,27 @@ +weird.js(1,1): error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +weird.js(1,23): error TS7006: Parameter 'BaseClass' implicitly has an 'any' type. +weird.js(9,17): error TS7006: Parameter 'error' implicitly has an 'any' type. + + +==== weird.js (3 errors) ==== + someFunction(function(BaseClass) { + ~~~~~~~~~~~~ +!!! error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +!!! related TS2728 lib.es5.d.ts:--:--: 'Function' is declared here. + ~~~~~~~~~ +!!! error TS7006: Parameter 'BaseClass' implicitly has an 'any' type. + 'use strict'; + const DEFAULT_MESSAGE = "nop!"; + class Hello extends BaseClass { + constructor() { + super(); + this.foo = "bar"; + } + _render(error) { + ~~~~~ +!!! error TS7006: Parameter 'error' implicitly has an 'any' type. + const message = error.message || DEFAULT_MESSAGE; + } + } + }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).symbols new file mode 100644 index 0000000000000..99ddd57e9d8cd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts] //// + +=== weird.js === +someFunction(function(BaseClass) { +>BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) + + 'use strict'; + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + + class Hello extends BaseClass { +>Hello : Symbol(Hello, Decl(weird.js, 2, 35)) +>BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) + + constructor() { + super(); + this.foo = "bar"; +>this.foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) +>this : Symbol(Hello, Decl(weird.js, 2, 35)) +>foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) + } + _render(error) { +>_render : Symbol(Hello._render, Decl(weird.js, 7, 9)) +>error : Symbol(error, Decl(weird.js, 8, 16)) + + const message = error.message || DEFAULT_MESSAGE; +>message : Symbol(message, Decl(weird.js, 9, 17)) +>error : Symbol(error, Decl(weird.js, 8, 16)) +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + } + } +}); + diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).types new file mode 100644 index 0000000000000..7f98768cc3b3e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts] //// + +=== weird.js === +someFunction(function(BaseClass) { +>someFunction(function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }}) : any +>someFunction : any +>function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }} : (BaseClass: any) => void +>BaseClass : any + + 'use strict'; +>'use strict' : "use strict" + + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : "nop!" +>"nop!" : "nop!" + + class Hello extends BaseClass { +>Hello : Hello +>BaseClass : any + + constructor() { + super(); +>super() : void +>super : any + + this.foo = "bar"; +>this.foo = "bar" : "bar" +>this.foo : any +>this : this +>foo : any +>"bar" : "bar" + } + _render(error) { +>_render : (error: any) => void +>error : any + + const message = error.message || DEFAULT_MESSAGE; +>message : any +>error.message || DEFAULT_MESSAGE : any +>error.message : any +>error : any +>message : any +>DEFAULT_MESSAGE : "nop!" + } + } +}); + diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..fa22beceb33e2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt @@ -0,0 +1,27 @@ +weird.js(1,1): error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +weird.js(1,23): error TS7006: Parameter 'BaseClass' implicitly has an 'any' type. +weird.js(9,17): error TS7006: Parameter 'error' implicitly has an 'any' type. + + +==== weird.js (3 errors) ==== + someFunction(function(BaseClass) { + ~~~~~~~~~~~~ +!!! error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +!!! related TS2728 lib.es5.d.ts:--:--: 'Function' is declared here. + ~~~~~~~~~ +!!! error TS7006: Parameter 'BaseClass' implicitly has an 'any' type. + 'use strict'; + const DEFAULT_MESSAGE = "nop!"; + class Hello extends BaseClass { + constructor() { + super(); + this.foo = "bar"; + } + _render(error) { + ~~~~~ +!!! error TS7006: Parameter 'error' implicitly has an 'any' type. + const message = error.message || DEFAULT_MESSAGE; + } + } + }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..99ddd57e9d8cd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts] //// + +=== weird.js === +someFunction(function(BaseClass) { +>BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) + + 'use strict'; + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + + class Hello extends BaseClass { +>Hello : Symbol(Hello, Decl(weird.js, 2, 35)) +>BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) + + constructor() { + super(); + this.foo = "bar"; +>this.foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) +>this : Symbol(Hello, Decl(weird.js, 2, 35)) +>foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) + } + _render(error) { +>_render : Symbol(Hello._render, Decl(weird.js, 7, 9)) +>error : Symbol(error, Decl(weird.js, 8, 16)) + + const message = error.message || DEFAULT_MESSAGE; +>message : Symbol(message, Decl(weird.js, 9, 17)) +>error : Symbol(error, Decl(weird.js, 8, 16)) +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + } + } +}); + diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).types new file mode 100644 index 0000000000000..7f98768cc3b3e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts] //// + +=== weird.js === +someFunction(function(BaseClass) { +>someFunction(function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }}) : any +>someFunction : any +>function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }} : (BaseClass: any) => void +>BaseClass : any + + 'use strict'; +>'use strict' : "use strict" + + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : "nop!" +>"nop!" : "nop!" + + class Hello extends BaseClass { +>Hello : Hello +>BaseClass : any + + constructor() { + super(); +>super() : void +>super : any + + this.foo = "bar"; +>this.foo = "bar" : "bar" +>this.foo : any +>this : this +>foo : any +>"bar" : "bar" + } + _render(error) { +>_render : (error: any) => void +>error : any + + const message = error.message || DEFAULT_MESSAGE; +>message : any +>error.message || DEFAULT_MESSAGE : any +>error.message : any +>error : any +>message : any +>DEFAULT_MESSAGE : "nop!" + } + } +}); + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt new file mode 100644 index 0000000000000..126b9485926f5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt @@ -0,0 +1,27 @@ +a.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +a.ts(5,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. +b.ts(2,11): error TS2322: Type 'string' is not assignable to type 'number'. +b.ts(2,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + + +==== a.ts (2 errors) ==== + type S = string | Promise; + declare const s: S; + declare const p: Promise; + async function f1() { + const a: number = await p; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + +==== b.ts (2 errors) ==== + async function f2() { + const b: number = await s; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).symbols new file mode 100644 index 0000000000000..9bdecefb54f4f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : Symbol(S, Decl(a.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const s: S; +>s : Symbol(s, Decl(a.ts, 1, 13)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const p: Promise; +>p : Symbol(p, Decl(a.ts, 2, 13)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +async function f1() { +>f1 : Symbol(f1, Decl(a.ts, 2, 28)) + + const a: number = await p; +>a : Symbol(a, Decl(a.ts, 4, 9)) +>p : Symbol(p, Decl(a.ts, 2, 13)) +} + +=== b.ts === +async function f2() { +>f2 : Symbol(f2, Decl(b.ts, 0, 0)) + + const b: number = await s; +>b : Symbol(b, Decl(b.ts, 1, 9)) +>s : Symbol(s, Decl(a.ts, 1, 13)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).types new file mode 100644 index 0000000000000..6cbf09f81f2c8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : S + +declare const s: S; +>s : S + +declare const p: Promise; +>p : Promise + +async function f1() { +>f1 : () => Promise + + const a: number = await p; +>a : number +>await p : string +>p : Promise +} + +=== b.ts === +async function f2() { +>f2 : () => Promise + + const b: number = await s; +>b : number +>await s : string +>s : S +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).errors.txt new file mode 100644 index 0000000000000..126b9485926f5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).errors.txt @@ -0,0 +1,27 @@ +a.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +a.ts(5,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. +b.ts(2,11): error TS2322: Type 'string' is not assignable to type 'number'. +b.ts(2,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + + +==== a.ts (2 errors) ==== + type S = string | Promise; + declare const s: S; + declare const p: Promise; + async function f1() { + const a: number = await p; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + +==== b.ts (2 errors) ==== + async function f2() { + const b: number = await s; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).symbols new file mode 100644 index 0000000000000..9bdecefb54f4f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : Symbol(S, Decl(a.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const s: S; +>s : Symbol(s, Decl(a.ts, 1, 13)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const p: Promise; +>p : Symbol(p, Decl(a.ts, 2, 13)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +async function f1() { +>f1 : Symbol(f1, Decl(a.ts, 2, 28)) + + const a: number = await p; +>a : Symbol(a, Decl(a.ts, 4, 9)) +>p : Symbol(p, Decl(a.ts, 2, 13)) +} + +=== b.ts === +async function f2() { +>f2 : Symbol(f2, Decl(b.ts, 0, 0)) + + const b: number = await s; +>b : Symbol(b, Decl(b.ts, 1, 9)) +>s : Symbol(s, Decl(a.ts, 1, 13)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).types new file mode 100644 index 0000000000000..6cbf09f81f2c8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : S + +declare const s: S; +>s : S + +declare const p: Promise; +>p : Promise + +async function f1() { +>f1 : () => Promise + + const a: number = await p; +>a : number +>await p : string +>p : Promise +} + +=== b.ts === +async function f2() { +>f2 : () => Promise + + const b: number = await s; +>b : number +>await s : string +>s : S +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt new file mode 100644 index 0000000000000..126b9485926f5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt @@ -0,0 +1,27 @@ +a.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +a.ts(5,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. +b.ts(2,11): error TS2322: Type 'string' is not assignable to type 'number'. +b.ts(2,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + + +==== a.ts (2 errors) ==== + type S = string | Promise; + declare const s: S; + declare const p: Promise; + async function f1() { + const a: number = await p; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + +==== b.ts (2 errors) ==== + async function f2() { + const b: number = await s; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).symbols new file mode 100644 index 0000000000000..9bdecefb54f4f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : Symbol(S, Decl(a.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const s: S; +>s : Symbol(s, Decl(a.ts, 1, 13)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const p: Promise; +>p : Symbol(p, Decl(a.ts, 2, 13)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +async function f1() { +>f1 : Symbol(f1, Decl(a.ts, 2, 28)) + + const a: number = await p; +>a : Symbol(a, Decl(a.ts, 4, 9)) +>p : Symbol(p, Decl(a.ts, 2, 13)) +} + +=== b.ts === +async function f2() { +>f2 : Symbol(f2, Decl(b.ts, 0, 0)) + + const b: number = await s; +>b : Symbol(b, Decl(b.ts, 1, 9)) +>s : Symbol(s, Decl(a.ts, 1, 13)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).types new file mode 100644 index 0000000000000..6cbf09f81f2c8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : S + +declare const s: S; +>s : S + +declare const p: Promise; +>p : Promise + +async function f1() { +>f1 : () => Promise + + const a: number = await p; +>a : number +>await p : string +>p : Promise +} + +=== b.ts === +async function f2() { +>f2 : () => Promise + + const b: number = await s; +>b : number +>await s : string +>s : S +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..126b9485926f5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt @@ -0,0 +1,27 @@ +a.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +a.ts(5,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. +b.ts(2,11): error TS2322: Type 'string' is not assignable to type 'number'. +b.ts(2,23): error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + + +==== a.ts (2 errors) ==== + type S = string | Promise; + declare const s: S; + declare const p: Promise; + async function f1() { + const a: number = await p; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + +==== b.ts (2 errors) ==== + async function f2() { + const b: number = await s; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + ~~~~~~~ +!!! error TS1062: Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..9bdecefb54f4f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : Symbol(S, Decl(a.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const s: S; +>s : Symbol(s, Decl(a.ts, 1, 13)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +declare const p: Promise; +>p : Symbol(p, Decl(a.ts, 2, 13)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>S : Symbol(S, Decl(a.ts, 0, 0)) + +async function f1() { +>f1 : Symbol(f1, Decl(a.ts, 2, 28)) + + const a: number = await p; +>a : Symbol(a, Decl(a.ts, 4, 9)) +>p : Symbol(p, Decl(a.ts, 2, 13)) +} + +=== b.ts === +async function f2() { +>f2 : Symbol(f2, Decl(b.ts, 0, 0)) + + const b: number = await s; +>b : Symbol(b, Decl(b.ts, 1, 9)) +>s : Symbol(s, Decl(a.ts, 1, 13)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).types new file mode 100644 index 0000000000000..6cbf09f81f2c8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderAwaitedCycle.ts] //// + +=== a.ts === +type S = string | Promise; +>S : S + +declare const s: S; +>s : S + +declare const p: Promise; +>p : Promise + +async function f1() { +>f1 : () => Promise + + const a: number = await p; +>a : number +>await p : string +>p : Promise +} + +=== b.ts === +async function f2() { +>f2 : () => Promise + + const b: number = await s; +>b : number +>await s : string +>s : S +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt new file mode 100644 index 0000000000000..9309ae4c7eb15 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt @@ -0,0 +1,37 @@ +checkOrderCircularConstraint.ts(4,19): error TS2313: Type parameter 'T' has a circular constraint. +checkOrderCircularConstraint.ts(7,19): error TS2339: Property 'foo' does not exist on type 'T'. +checkOrderCircularConstraint.ts(8,21): error TS2351: This expression is not constructable. + Type 'unknown' has no construct signatures. +checkOrderCircularConstraint.ts(9,17): error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. + Property '1' does not exist on type 'unknown'. +checkOrderCircularConstraint.ts(10,17): error TS2349: This expression is not callable. + Type 'unknown' has no call signatures. + + +==== checkOrderCircularConstraint.ts (5 errors) ==== + // A circular constraint of a declared type parameter is reported at its + // declaration, regardless of which use resolves the constraint first. + + class A { + ~ +!!! error TS2313: Type parameter 'T' has a circular constraint. + foo() { + var x!: T; + var a = x.foo(); + ~~~ +!!! error TS2339: Property 'foo' does not exist on type 'T'. + var b = new x(123); + ~ +!!! error TS2351: This expression is not constructable. +!!! error TS2351: Type 'unknown' has no construct signatures. + var c = x[1]; + ~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. +!!! error TS7053: Property '1' does not exist on type 'unknown'. + var d = x(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'unknown' has no call signatures. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).js new file mode 100644 index 0000000000000..3c72daa68bbd3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +//// [checkOrderCircularConstraint.ts] +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { + foo() { + var x!: T; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} + + +//// [checkOrderCircularConstraint.js] +"use strict"; +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. +class A { + foo() { + var x; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).symbols new file mode 100644 index 0000000000000..9b87b04754b9f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : Symbol(A, Decl(checkOrderCircularConstraint.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + foo() { +>foo : Symbol(A.foo, Decl(checkOrderCircularConstraint.ts, 3, 22)) + + var x!: T; +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + var a = x.foo(); +>a : Symbol(a, Decl(checkOrderCircularConstraint.ts, 6, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var b = new x(123); +>b : Symbol(b, Decl(checkOrderCircularConstraint.ts, 7, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var c = x[1]; +>c : Symbol(c, Decl(checkOrderCircularConstraint.ts, 8, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var d = x(); +>d : Symbol(d, Decl(checkOrderCircularConstraint.ts, 9, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).types new file mode 100644 index 0000000000000..370c13c086d5a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : A + + foo() { +>foo : () => void + + var x!: T; +>x : T + + var a = x.foo(); +>a : any +>x.foo() : any +>x.foo : any +>x : T +>foo : any + + var b = new x(123); +>b : any +>new x(123) : any +>x : T +>123 : 123 + + var c = x[1]; +>c : any +>x[1] : any +>x : T +>1 : 1 + + var d = x(); +>d : any +>x() : any +>x : T + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).errors.txt new file mode 100644 index 0000000000000..9309ae4c7eb15 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).errors.txt @@ -0,0 +1,37 @@ +checkOrderCircularConstraint.ts(4,19): error TS2313: Type parameter 'T' has a circular constraint. +checkOrderCircularConstraint.ts(7,19): error TS2339: Property 'foo' does not exist on type 'T'. +checkOrderCircularConstraint.ts(8,21): error TS2351: This expression is not constructable. + Type 'unknown' has no construct signatures. +checkOrderCircularConstraint.ts(9,17): error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. + Property '1' does not exist on type 'unknown'. +checkOrderCircularConstraint.ts(10,17): error TS2349: This expression is not callable. + Type 'unknown' has no call signatures. + + +==== checkOrderCircularConstraint.ts (5 errors) ==== + // A circular constraint of a declared type parameter is reported at its + // declaration, regardless of which use resolves the constraint first. + + class A { + ~ +!!! error TS2313: Type parameter 'T' has a circular constraint. + foo() { + var x!: T; + var a = x.foo(); + ~~~ +!!! error TS2339: Property 'foo' does not exist on type 'T'. + var b = new x(123); + ~ +!!! error TS2351: This expression is not constructable. +!!! error TS2351: Type 'unknown' has no construct signatures. + var c = x[1]; + ~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. +!!! error TS7053: Property '1' does not exist on type 'unknown'. + var d = x(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'unknown' has no call signatures. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).js new file mode 100644 index 0000000000000..3c72daa68bbd3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +//// [checkOrderCircularConstraint.ts] +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { + foo() { + var x!: T; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} + + +//// [checkOrderCircularConstraint.js] +"use strict"; +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. +class A { + foo() { + var x; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).symbols new file mode 100644 index 0000000000000..9b87b04754b9f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : Symbol(A, Decl(checkOrderCircularConstraint.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + foo() { +>foo : Symbol(A.foo, Decl(checkOrderCircularConstraint.ts, 3, 22)) + + var x!: T; +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + var a = x.foo(); +>a : Symbol(a, Decl(checkOrderCircularConstraint.ts, 6, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var b = new x(123); +>b : Symbol(b, Decl(checkOrderCircularConstraint.ts, 7, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var c = x[1]; +>c : Symbol(c, Decl(checkOrderCircularConstraint.ts, 8, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var d = x(); +>d : Symbol(d, Decl(checkOrderCircularConstraint.ts, 9, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).types new file mode 100644 index 0000000000000..370c13c086d5a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : A + + foo() { +>foo : () => void + + var x!: T; +>x : T + + var a = x.foo(); +>a : any +>x.foo() : any +>x.foo : any +>x : T +>foo : any + + var b = new x(123); +>b : any +>new x(123) : any +>x : T +>123 : 123 + + var c = x[1]; +>c : any +>x[1] : any +>x : T +>1 : 1 + + var d = x(); +>d : any +>x() : any +>x : T + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt new file mode 100644 index 0000000000000..9309ae4c7eb15 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt @@ -0,0 +1,37 @@ +checkOrderCircularConstraint.ts(4,19): error TS2313: Type parameter 'T' has a circular constraint. +checkOrderCircularConstraint.ts(7,19): error TS2339: Property 'foo' does not exist on type 'T'. +checkOrderCircularConstraint.ts(8,21): error TS2351: This expression is not constructable. + Type 'unknown' has no construct signatures. +checkOrderCircularConstraint.ts(9,17): error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. + Property '1' does not exist on type 'unknown'. +checkOrderCircularConstraint.ts(10,17): error TS2349: This expression is not callable. + Type 'unknown' has no call signatures. + + +==== checkOrderCircularConstraint.ts (5 errors) ==== + // A circular constraint of a declared type parameter is reported at its + // declaration, regardless of which use resolves the constraint first. + + class A { + ~ +!!! error TS2313: Type parameter 'T' has a circular constraint. + foo() { + var x!: T; + var a = x.foo(); + ~~~ +!!! error TS2339: Property 'foo' does not exist on type 'T'. + var b = new x(123); + ~ +!!! error TS2351: This expression is not constructable. +!!! error TS2351: Type 'unknown' has no construct signatures. + var c = x[1]; + ~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. +!!! error TS7053: Property '1' does not exist on type 'unknown'. + var d = x(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'unknown' has no call signatures. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).js new file mode 100644 index 0000000000000..3c72daa68bbd3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +//// [checkOrderCircularConstraint.ts] +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { + foo() { + var x!: T; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} + + +//// [checkOrderCircularConstraint.js] +"use strict"; +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. +class A { + foo() { + var x; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).symbols new file mode 100644 index 0000000000000..9b87b04754b9f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : Symbol(A, Decl(checkOrderCircularConstraint.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + foo() { +>foo : Symbol(A.foo, Decl(checkOrderCircularConstraint.ts, 3, 22)) + + var x!: T; +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + var a = x.foo(); +>a : Symbol(a, Decl(checkOrderCircularConstraint.ts, 6, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var b = new x(123); +>b : Symbol(b, Decl(checkOrderCircularConstraint.ts, 7, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var c = x[1]; +>c : Symbol(c, Decl(checkOrderCircularConstraint.ts, 8, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var d = x(); +>d : Symbol(d, Decl(checkOrderCircularConstraint.ts, 9, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).types new file mode 100644 index 0000000000000..370c13c086d5a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : A + + foo() { +>foo : () => void + + var x!: T; +>x : T + + var a = x.foo(); +>a : any +>x.foo() : any +>x.foo : any +>x : T +>foo : any + + var b = new x(123); +>b : any +>new x(123) : any +>x : T +>123 : 123 + + var c = x[1]; +>c : any +>x[1] : any +>x : T +>1 : 1 + + var d = x(); +>d : any +>x() : any +>x : T + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..9309ae4c7eb15 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt @@ -0,0 +1,37 @@ +checkOrderCircularConstraint.ts(4,19): error TS2313: Type parameter 'T' has a circular constraint. +checkOrderCircularConstraint.ts(7,19): error TS2339: Property 'foo' does not exist on type 'T'. +checkOrderCircularConstraint.ts(8,21): error TS2351: This expression is not constructable. + Type 'unknown' has no construct signatures. +checkOrderCircularConstraint.ts(9,17): error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. + Property '1' does not exist on type 'unknown'. +checkOrderCircularConstraint.ts(10,17): error TS2349: This expression is not callable. + Type 'unknown' has no call signatures. + + +==== checkOrderCircularConstraint.ts (5 errors) ==== + // A circular constraint of a declared type parameter is reported at its + // declaration, regardless of which use resolves the constraint first. + + class A { + ~ +!!! error TS2313: Type parameter 'T' has a circular constraint. + foo() { + var x!: T; + var a = x.foo(); + ~~~ +!!! error TS2339: Property 'foo' does not exist on type 'T'. + var b = new x(123); + ~ +!!! error TS2351: This expression is not constructable. +!!! error TS2351: Type 'unknown' has no construct signatures. + var c = x[1]; + ~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type '1' can't be used to index type 'unknown'. +!!! error TS7053: Property '1' does not exist on type 'unknown'. + var d = x(); + ~ +!!! error TS2349: This expression is not callable. +!!! error TS2349: Type 'unknown' has no call signatures. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).js new file mode 100644 index 0000000000000..3c72daa68bbd3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +//// [checkOrderCircularConstraint.ts] +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { + foo() { + var x!: T; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} + + +//// [checkOrderCircularConstraint.js] +"use strict"; +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. +class A { + foo() { + var x; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..9b87b04754b9f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : Symbol(A, Decl(checkOrderCircularConstraint.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + foo() { +>foo : Symbol(A.foo, Decl(checkOrderCircularConstraint.ts, 3, 22)) + + var x!: T; +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) +>T : Symbol(T, Decl(checkOrderCircularConstraint.ts, 3, 8)) + + var a = x.foo(); +>a : Symbol(a, Decl(checkOrderCircularConstraint.ts, 6, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var b = new x(123); +>b : Symbol(b, Decl(checkOrderCircularConstraint.ts, 7, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var c = x[1]; +>c : Symbol(c, Decl(checkOrderCircularConstraint.ts, 8, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + + var d = x(); +>d : Symbol(d, Decl(checkOrderCircularConstraint.ts, 9, 11)) +>x : Symbol(x, Decl(checkOrderCircularConstraint.ts, 5, 11)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).types new file mode 100644 index 0000000000000..370c13c086d5a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/checkOrderCircularConstraint.ts] //// + +=== checkOrderCircularConstraint.ts === +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { +>A : A + + foo() { +>foo : () => void + + var x!: T; +>x : T + + var a = x.foo(); +>a : any +>x.foo() : any +>x.foo : any +>x : T +>foo : any + + var b = new x(123); +>b : any +>new x(123) : any +>x : T +>123 : 123 + + var c = x[1]; +>c : any +>x[1] : any +>x : T +>1 : 1 + + var d = x(); +>d : any +>x() : any +>x : T + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt new file mode 100644 index 0000000000000..4dee4171e029f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt @@ -0,0 +1,15 @@ +b.ts(2,24): error TS2716: Type parameter 'U' has a circular default. + + +==== a.ts (0 errors) ==== + import type { B } from "./b"; + export interface A { a: T } + export declare const a: A; + +==== b.ts (1 errors) ==== + import type { A } from "./a"; + export interface B { b: U } + ~ +!!! error TS2716: Type parameter 'U' has a circular default. + export declare const b: B; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).js new file mode 100644 index 0000000000000..8f10482f060d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).js @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +//// [a.ts] +import type { B } from "./b"; +export interface A { a: T } +export declare const a: A; + +//// [b.ts] +import type { A } from "./a"; +export interface B { b: U } +export declare const b: B; + + +//// [b.js] +export {}; +//// [a.js] +export {}; + + +//// [b.d.ts] +import type { A } from "./a"; +export interface B { + b: U; +} +export declare const b: B; +//// [a.d.ts] +import type { B } from "./b"; +export interface A { + a: T; +} +export declare const a: A; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).symbols new file mode 100644 index 0000000000000..72d2e540fd379 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : Symbol(B, Decl(a.ts, 0, 13)) + +export interface A { a: T } +>A : Symbol(A, Decl(a.ts, 0, 29)) +>T : Symbol(T, Decl(a.ts, 1, 19)) +>B : Symbol(B, Decl(a.ts, 0, 13)) +>a : Symbol(A.a, Decl(a.ts, 1, 27)) +>T : Symbol(T, Decl(a.ts, 1, 19)) + +export declare const a: A; +>a : Symbol(a, Decl(a.ts, 2, 20)) +>A : Symbol(A, Decl(a.ts, 0, 29)) + +=== b.ts === +import type { A } from "./a"; +>A : Symbol(A, Decl(b.ts, 0, 13)) + +export interface B { b: U } +>B : Symbol(B, Decl(b.ts, 0, 29)) +>U : Symbol(U, Decl(b.ts, 1, 19)) +>A : Symbol(A, Decl(b.ts, 0, 13)) +>b : Symbol(B.b, Decl(b.ts, 1, 27)) +>U : Symbol(U, Decl(b.ts, 1, 19)) + +export declare const b: B; +>b : Symbol(b, Decl(b.ts, 2, 20)) +>B : Symbol(B, Decl(b.ts, 0, 29)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).types new file mode 100644 index 0000000000000..a88d998c374ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).types @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : B + +export interface A { a: T } +>a : T + +export declare const a: A; +>a : A> + +=== b.ts === +import type { A } from "./a"; +>A : A + +export interface B { b: U } +>b : U + +export declare const b: B; +>b : B + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).errors.txt new file mode 100644 index 0000000000000..4dee4171e029f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).errors.txt @@ -0,0 +1,15 @@ +b.ts(2,24): error TS2716: Type parameter 'U' has a circular default. + + +==== a.ts (0 errors) ==== + import type { B } from "./b"; + export interface A { a: T } + export declare const a: A; + +==== b.ts (1 errors) ==== + import type { A } from "./a"; + export interface B { b: U } + ~ +!!! error TS2716: Type parameter 'U' has a circular default. + export declare const b: B; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).js new file mode 100644 index 0000000000000..8f10482f060d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).js @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +//// [a.ts] +import type { B } from "./b"; +export interface A { a: T } +export declare const a: A; + +//// [b.ts] +import type { A } from "./a"; +export interface B { b: U } +export declare const b: B; + + +//// [b.js] +export {}; +//// [a.js] +export {}; + + +//// [b.d.ts] +import type { A } from "./a"; +export interface B { + b: U; +} +export declare const b: B; +//// [a.d.ts] +import type { B } from "./b"; +export interface A { + a: T; +} +export declare const a: A; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).symbols new file mode 100644 index 0000000000000..72d2e540fd379 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : Symbol(B, Decl(a.ts, 0, 13)) + +export interface A { a: T } +>A : Symbol(A, Decl(a.ts, 0, 29)) +>T : Symbol(T, Decl(a.ts, 1, 19)) +>B : Symbol(B, Decl(a.ts, 0, 13)) +>a : Symbol(A.a, Decl(a.ts, 1, 27)) +>T : Symbol(T, Decl(a.ts, 1, 19)) + +export declare const a: A; +>a : Symbol(a, Decl(a.ts, 2, 20)) +>A : Symbol(A, Decl(a.ts, 0, 29)) + +=== b.ts === +import type { A } from "./a"; +>A : Symbol(A, Decl(b.ts, 0, 13)) + +export interface B { b: U } +>B : Symbol(B, Decl(b.ts, 0, 29)) +>U : Symbol(U, Decl(b.ts, 1, 19)) +>A : Symbol(A, Decl(b.ts, 0, 13)) +>b : Symbol(B.b, Decl(b.ts, 1, 27)) +>U : Symbol(U, Decl(b.ts, 1, 19)) + +export declare const b: B; +>b : Symbol(b, Decl(b.ts, 2, 20)) +>B : Symbol(B, Decl(b.ts, 0, 29)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).types new file mode 100644 index 0000000000000..a88d998c374ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).types @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : B + +export interface A { a: T } +>a : T + +export declare const a: A; +>a : A> + +=== b.ts === +import type { A } from "./a"; +>A : A + +export interface B { b: U } +>b : U + +export declare const b: B; +>b : B + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).errors.txt new file mode 100644 index 0000000000000..4dee4171e029f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).errors.txt @@ -0,0 +1,15 @@ +b.ts(2,24): error TS2716: Type parameter 'U' has a circular default. + + +==== a.ts (0 errors) ==== + import type { B } from "./b"; + export interface A { a: T } + export declare const a: A; + +==== b.ts (1 errors) ==== + import type { A } from "./a"; + export interface B { b: U } + ~ +!!! error TS2716: Type parameter 'U' has a circular default. + export declare const b: B; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).js new file mode 100644 index 0000000000000..8f10482f060d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).js @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +//// [a.ts] +import type { B } from "./b"; +export interface A { a: T } +export declare const a: A; + +//// [b.ts] +import type { A } from "./a"; +export interface B { b: U } +export declare const b: B; + + +//// [b.js] +export {}; +//// [a.js] +export {}; + + +//// [b.d.ts] +import type { A } from "./a"; +export interface B { + b: U; +} +export declare const b: B; +//// [a.d.ts] +import type { B } from "./b"; +export interface A { + a: T; +} +export declare const a: A; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).symbols new file mode 100644 index 0000000000000..72d2e540fd379 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : Symbol(B, Decl(a.ts, 0, 13)) + +export interface A { a: T } +>A : Symbol(A, Decl(a.ts, 0, 29)) +>T : Symbol(T, Decl(a.ts, 1, 19)) +>B : Symbol(B, Decl(a.ts, 0, 13)) +>a : Symbol(A.a, Decl(a.ts, 1, 27)) +>T : Symbol(T, Decl(a.ts, 1, 19)) + +export declare const a: A; +>a : Symbol(a, Decl(a.ts, 2, 20)) +>A : Symbol(A, Decl(a.ts, 0, 29)) + +=== b.ts === +import type { A } from "./a"; +>A : Symbol(A, Decl(b.ts, 0, 13)) + +export interface B { b: U } +>B : Symbol(B, Decl(b.ts, 0, 29)) +>U : Symbol(U, Decl(b.ts, 1, 19)) +>A : Symbol(A, Decl(b.ts, 0, 13)) +>b : Symbol(B.b, Decl(b.ts, 1, 27)) +>U : Symbol(U, Decl(b.ts, 1, 19)) + +export declare const b: B; +>b : Symbol(b, Decl(b.ts, 2, 20)) +>B : Symbol(B, Decl(b.ts, 0, 29)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).types new file mode 100644 index 0000000000000..a88d998c374ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).types @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : B + +export interface A { a: T } +>a : T + +export declare const a: A; +>a : A> + +=== b.ts === +import type { A } from "./a"; +>A : A + +export interface B { b: U } +>b : U + +export declare const b: B; +>b : B + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..4dee4171e029f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).errors.txt @@ -0,0 +1,15 @@ +b.ts(2,24): error TS2716: Type parameter 'U' has a circular default. + + +==== a.ts (0 errors) ==== + import type { B } from "./b"; + export interface A { a: T } + export declare const a: A; + +==== b.ts (1 errors) ==== + import type { A } from "./a"; + export interface B { b: U } + ~ +!!! error TS2716: Type parameter 'U' has a circular default. + export declare const b: B; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).js new file mode 100644 index 0000000000000..8f10482f060d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).js @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +//// [a.ts] +import type { B } from "./b"; +export interface A { a: T } +export declare const a: A; + +//// [b.ts] +import type { A } from "./a"; +export interface B { b: U } +export declare const b: B; + + +//// [b.js] +export {}; +//// [a.js] +export {}; + + +//// [b.d.ts] +import type { A } from "./a"; +export interface B { + b: U; +} +export declare const b: B; +//// [a.d.ts] +import type { B } from "./b"; +export interface A { + a: T; +} +export declare const a: A; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..72d2e540fd379 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : Symbol(B, Decl(a.ts, 0, 13)) + +export interface A { a: T } +>A : Symbol(A, Decl(a.ts, 0, 29)) +>T : Symbol(T, Decl(a.ts, 1, 19)) +>B : Symbol(B, Decl(a.ts, 0, 13)) +>a : Symbol(A.a, Decl(a.ts, 1, 27)) +>T : Symbol(T, Decl(a.ts, 1, 19)) + +export declare const a: A; +>a : Symbol(a, Decl(a.ts, 2, 20)) +>A : Symbol(A, Decl(a.ts, 0, 29)) + +=== b.ts === +import type { A } from "./a"; +>A : Symbol(A, Decl(b.ts, 0, 13)) + +export interface B { b: U } +>B : Symbol(B, Decl(b.ts, 0, 29)) +>U : Symbol(U, Decl(b.ts, 1, 19)) +>A : Symbol(A, Decl(b.ts, 0, 13)) +>b : Symbol(B.b, Decl(b.ts, 1, 27)) +>U : Symbol(U, Decl(b.ts, 1, 19)) + +export declare const b: B; +>b : Symbol(b, Decl(b.ts, 2, 20)) +>B : Symbol(B, Decl(b.ts, 0, 29)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).types new file mode 100644 index 0000000000000..a88d998c374ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).types @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/checkOrderCircularDefaults.ts] //// + +=== a.ts === +import type { B } from "./b"; +>B : B + +export interface A { a: T } +>a : T + +export declare const a: A; +>a : A> + +=== b.ts === +import type { A } from "./a"; +>A : A + +export interface B { b: U } +>b : U + +export declare const b: B; +>b : B + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).errors.txt new file mode 100644 index 0000000000000..81bd46c132406 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).errors.txt @@ -0,0 +1,25 @@ +checkOrderEmitBeforeCheck.ts(9,5): error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. +checkOrderEmitBeforeCheck.ts(9,13): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; each: any; }'. + + +==== checkOrderEmitBeforeCheck.ts (2 errors) ==== + // The circularity in the mapped type is found by checking the annotation of + // "each". Emitting first must not instead report it at the use import + // elision visits, nor cache the result without the error. + type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; + type Child = { [P in NonOptionalKeys]: T[P] } + + export interface ListWidget { + "type": "list", + "each": Child; + ~~~~~~ +!!! error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. + ~~~~~~~~~~~~~~~~~ +!!! error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; each: any; }'. + } + + type ListChild = Child + + declare let x: ListChild; + x.type; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).js new file mode 100644 index 0000000000000..0ceb03c6477d2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).js @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/checkOrderEmitBeforeCheck.ts] //// + +//// [checkOrderEmitBeforeCheck.ts] +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +type Child = { [P in NonOptionalKeys]: T[P] } + +export interface ListWidget { + "type": "list", + "each": Child; +} + +type ListChild = Child + +declare let x: ListChild; +x.type; + + +//// [checkOrderEmitBeforeCheck.js] +x.type; +export {}; + + +//// [checkOrderEmitBeforeCheck.d.ts] +type NonOptionalKeys = { + [P in keyof T]: undefined extends T[P] ? never : P; +}[keyof T]; +type Child = { + [P in NonOptionalKeys]: T[P]; +}; +export interface ListWidget { + "type": "list"; + "each": Child; +} +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).symbols new file mode 100644 index 0000000000000..9de1daaccd55e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).symbols @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/checkOrderEmitBeforeCheck.ts] //// + +=== checkOrderEmitBeforeCheck.ts === +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +>NonOptionalKeys : Symbol(NonOptionalKeys, Decl(checkOrderEmitBeforeCheck.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 3, 29)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 3, 29)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 3, 29)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) + +type Child = { [P in NonOptionalKeys]: T[P] } +>Child : Symbol(Child, Decl(checkOrderEmitBeforeCheck.ts, 3, 90)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 4, 11)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 4, 19)) +>NonOptionalKeys : Symbol(NonOptionalKeys, Decl(checkOrderEmitBeforeCheck.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 4, 11)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 4, 11)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 4, 19)) + +export interface ListWidget { +>ListWidget : Symbol(ListWidget, Decl(checkOrderEmitBeforeCheck.ts, 4, 51)) + + "type": "list", +>"type" : Symbol(ListWidget["type"], Decl(checkOrderEmitBeforeCheck.ts, 6, 29)) + + "each": Child; +>"each" : Symbol(ListWidget["each"], Decl(checkOrderEmitBeforeCheck.ts, 7, 19)) +>Child : Symbol(Child, Decl(checkOrderEmitBeforeCheck.ts, 3, 90)) +>ListWidget : Symbol(ListWidget, Decl(checkOrderEmitBeforeCheck.ts, 4, 51)) +} + +type ListChild = Child +>ListChild : Symbol(ListChild, Decl(checkOrderEmitBeforeCheck.ts, 9, 1)) +>Child : Symbol(Child, Decl(checkOrderEmitBeforeCheck.ts, 3, 90)) +>ListWidget : Symbol(ListWidget, Decl(checkOrderEmitBeforeCheck.ts, 4, 51)) + +declare let x: ListChild; +>x : Symbol(x, Decl(checkOrderEmitBeforeCheck.ts, 13, 11)) +>ListChild : Symbol(ListChild, Decl(checkOrderEmitBeforeCheck.ts, 9, 1)) + +x.type; +>x : Symbol(x, Decl(checkOrderEmitBeforeCheck.ts, 13, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).types new file mode 100644 index 0000000000000..dfa8cb7adbabd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderEmitBeforeCheck.ts] //// + +=== checkOrderEmitBeforeCheck.ts === +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +>NonOptionalKeys : NonOptionalKeys + +type Child = { [P in NonOptionalKeys]: T[P] } +>Child : Child + +export interface ListWidget { + "type": "list", +>"type" : "list" + + "each": Child; +>"each" : any +} + +type ListChild = Child +>ListChild : ListChild + +declare let x: ListChild; +>x : ListChild + +x.type; +>x.type : any +>x : ListChild +>type : any + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt new file mode 100644 index 0000000000000..81bd46c132406 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt @@ -0,0 +1,25 @@ +checkOrderEmitBeforeCheck.ts(9,5): error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. +checkOrderEmitBeforeCheck.ts(9,13): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; each: any; }'. + + +==== checkOrderEmitBeforeCheck.ts (2 errors) ==== + // The circularity in the mapped type is found by checking the annotation of + // "each". Emitting first must not instead report it at the use import + // elision visits, nor cache the result without the error. + type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; + type Child = { [P in NonOptionalKeys]: T[P] } + + export interface ListWidget { + "type": "list", + "each": Child; + ~~~~~~ +!!! error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. + ~~~~~~~~~~~~~~~~~ +!!! error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; each: any; }'. + } + + type ListChild = Child + + declare let x: ListChild; + x.type; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).js new file mode 100644 index 0000000000000..0ceb03c6477d2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).js @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/checkOrderEmitBeforeCheck.ts] //// + +//// [checkOrderEmitBeforeCheck.ts] +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +type Child = { [P in NonOptionalKeys]: T[P] } + +export interface ListWidget { + "type": "list", + "each": Child; +} + +type ListChild = Child + +declare let x: ListChild; +x.type; + + +//// [checkOrderEmitBeforeCheck.js] +x.type; +export {}; + + +//// [checkOrderEmitBeforeCheck.d.ts] +type NonOptionalKeys = { + [P in keyof T]: undefined extends T[P] ? never : P; +}[keyof T]; +type Child = { + [P in NonOptionalKeys]: T[P]; +}; +export interface ListWidget { + "type": "list"; + "each": Child; +} +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).symbols new file mode 100644 index 0000000000000..9de1daaccd55e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).symbols @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/checkOrderEmitBeforeCheck.ts] //// + +=== checkOrderEmitBeforeCheck.ts === +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +>NonOptionalKeys : Symbol(NonOptionalKeys, Decl(checkOrderEmitBeforeCheck.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 3, 29)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 3, 29)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 3, 29)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 3, 21)) + +type Child = { [P in NonOptionalKeys]: T[P] } +>Child : Symbol(Child, Decl(checkOrderEmitBeforeCheck.ts, 3, 90)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 4, 11)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 4, 19)) +>NonOptionalKeys : Symbol(NonOptionalKeys, Decl(checkOrderEmitBeforeCheck.ts, 0, 0)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 4, 11)) +>T : Symbol(T, Decl(checkOrderEmitBeforeCheck.ts, 4, 11)) +>P : Symbol(P, Decl(checkOrderEmitBeforeCheck.ts, 4, 19)) + +export interface ListWidget { +>ListWidget : Symbol(ListWidget, Decl(checkOrderEmitBeforeCheck.ts, 4, 51)) + + "type": "list", +>"type" : Symbol(ListWidget["type"], Decl(checkOrderEmitBeforeCheck.ts, 6, 29)) + + "each": Child; +>"each" : Symbol(ListWidget["each"], Decl(checkOrderEmitBeforeCheck.ts, 7, 19)) +>Child : Symbol(Child, Decl(checkOrderEmitBeforeCheck.ts, 3, 90)) +>ListWidget : Symbol(ListWidget, Decl(checkOrderEmitBeforeCheck.ts, 4, 51)) +} + +type ListChild = Child +>ListChild : Symbol(ListChild, Decl(checkOrderEmitBeforeCheck.ts, 9, 1)) +>Child : Symbol(Child, Decl(checkOrderEmitBeforeCheck.ts, 3, 90)) +>ListWidget : Symbol(ListWidget, Decl(checkOrderEmitBeforeCheck.ts, 4, 51)) + +declare let x: ListChild; +>x : Symbol(x, Decl(checkOrderEmitBeforeCheck.ts, 13, 11)) +>ListChild : Symbol(ListChild, Decl(checkOrderEmitBeforeCheck.ts, 9, 1)) + +x.type; +>x : Symbol(x, Decl(checkOrderEmitBeforeCheck.ts, 13, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).types new file mode 100644 index 0000000000000..dfa8cb7adbabd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/checkOrderEmitBeforeCheck.ts] //// + +=== checkOrderEmitBeforeCheck.ts === +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +>NonOptionalKeys : NonOptionalKeys + +type Child = { [P in NonOptionalKeys]: T[P] } +>Child : Child + +export interface ListWidget { + "type": "list", +>"type" : "list" + + "each": Child; +>"each" : any +} + +type ListChild = Child +>ListChild : ListChild + +declare let x: ListChild; +>x : ListChild + +x.type; +>x.type : any +>x : ListChild +>type : any + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).js new file mode 100644 index 0000000000000..fe0caa60a4dc6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +//// [checkOrderEnumComputedMember.ts] +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; + + +//// [checkOrderEnumComputedMember.js] +"use strict"; +var E; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = E.A.valueOf()] = "B"; + E[E["C"] = 1] = "C"; +})(E || (E = {})); +const member = E.C; + + +//// [checkOrderEnumComputedMember.d.ts] +declare enum E { + A = 0, + B, + C = 1 +} +declare const member: Extract; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).symbols new file mode 100644 index 0000000000000..543ee2b641c26 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) + + A = 0, +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) + + B = E.A.valueOf(), +>B : Symbol(E.B, Decl(checkOrderEnumComputedMember.ts, 1, 10)) +>E.A.valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) +>E.A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) + + C = 1, +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +} + +const member: Extract = E.C; +>member : Symbol(member, Decl(checkOrderEnumComputedMember.ts, 6, 5)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>E.C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).types new file mode 100644 index 0000000000000..39ddeced5f433 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : E + + A = 0, +>A : E.A +>0 : 0 + + B = E.A.valueOf(), +>B : E.B +>E.A.valueOf() : number +>E.A.valueOf : () => number +>E.A : E.A +>E : typeof E +>A : E.A +>valueOf : () => number + + C = 1, +>C : E.C +>1 : 1 +} + +const member: Extract = E.C; +>member : E.C +>E.C : E.C +>E : typeof E +>C : E.C + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).js new file mode 100644 index 0000000000000..fe0caa60a4dc6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +//// [checkOrderEnumComputedMember.ts] +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; + + +//// [checkOrderEnumComputedMember.js] +"use strict"; +var E; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = E.A.valueOf()] = "B"; + E[E["C"] = 1] = "C"; +})(E || (E = {})); +const member = E.C; + + +//// [checkOrderEnumComputedMember.d.ts] +declare enum E { + A = 0, + B, + C = 1 +} +declare const member: Extract; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).symbols new file mode 100644 index 0000000000000..543ee2b641c26 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) + + A = 0, +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) + + B = E.A.valueOf(), +>B : Symbol(E.B, Decl(checkOrderEnumComputedMember.ts, 1, 10)) +>E.A.valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) +>E.A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) + + C = 1, +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +} + +const member: Extract = E.C; +>member : Symbol(member, Decl(checkOrderEnumComputedMember.ts, 6, 5)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>E.C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types new file mode 100644 index 0000000000000..39ddeced5f433 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : E + + A = 0, +>A : E.A +>0 : 0 + + B = E.A.valueOf(), +>B : E.B +>E.A.valueOf() : number +>E.A.valueOf : () => number +>E.A : E.A +>E : typeof E +>A : E.A +>valueOf : () => number + + C = 1, +>C : E.C +>1 : 1 +} + +const member: Extract = E.C; +>member : E.C +>E.C : E.C +>E : typeof E +>C : E.C + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).js new file mode 100644 index 0000000000000..fe0caa60a4dc6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +//// [checkOrderEnumComputedMember.ts] +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; + + +//// [checkOrderEnumComputedMember.js] +"use strict"; +var E; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = E.A.valueOf()] = "B"; + E[E["C"] = 1] = "C"; +})(E || (E = {})); +const member = E.C; + + +//// [checkOrderEnumComputedMember.d.ts] +declare enum E { + A = 0, + B, + C = 1 +} +declare const member: Extract; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).symbols new file mode 100644 index 0000000000000..543ee2b641c26 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) + + A = 0, +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) + + B = E.A.valueOf(), +>B : Symbol(E.B, Decl(checkOrderEnumComputedMember.ts, 1, 10)) +>E.A.valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) +>E.A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) + + C = 1, +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +} + +const member: Extract = E.C; +>member : Symbol(member, Decl(checkOrderEnumComputedMember.ts, 6, 5)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>E.C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).types new file mode 100644 index 0000000000000..39ddeced5f433 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : E + + A = 0, +>A : E.A +>0 : 0 + + B = E.A.valueOf(), +>B : E.B +>E.A.valueOf() : number +>E.A.valueOf : () => number +>E.A : E.A +>E : typeof E +>A : E.A +>valueOf : () => number + + C = 1, +>C : E.C +>1 : 1 +} + +const member: Extract = E.C; +>member : E.C +>E.C : E.C +>E : typeof E +>C : E.C + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).js new file mode 100644 index 0000000000000..fe0caa60a4dc6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +//// [checkOrderEnumComputedMember.ts] +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; + + +//// [checkOrderEnumComputedMember.js] +"use strict"; +var E; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = E.A.valueOf()] = "B"; + E[E["C"] = 1] = "C"; +})(E || (E = {})); +const member = E.C; + + +//// [checkOrderEnumComputedMember.d.ts] +declare enum E { + A = 0, + B, + C = 1 +} +declare const member: Extract; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..543ee2b641c26 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) + + A = 0, +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) + + B = E.A.valueOf(), +>B : Symbol(E.B, Decl(checkOrderEnumComputedMember.ts, 1, 10)) +>E.A.valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) +>E.A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>A : Symbol(E.A, Decl(checkOrderEnumComputedMember.ts, 0, 8)) +>valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) + + C = 1, +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +} + +const member: Extract = E.C; +>member : Symbol(member, Decl(checkOrderEnumComputedMember.ts, 6, 5)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>E.C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) +>E : Symbol(E, Decl(checkOrderEnumComputedMember.ts, 0, 0)) +>C : Symbol(E.C, Decl(checkOrderEnumComputedMember.ts, 2, 22)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).types new file mode 100644 index 0000000000000..39ddeced5f433 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/checkOrderEnumComputedMember.ts] //// + +=== checkOrderEnumComputedMember.ts === +enum E { +>E : E + + A = 0, +>A : E.A +>0 : 0 + + B = E.A.valueOf(), +>B : E.B +>E.A.valueOf() : number +>E.A.valueOf : () => number +>E.A : E.A +>E : typeof E +>A : E.A +>valueOf : () => number + + C = 1, +>C : E.C +>1 : 1 +} + +const member: Extract = E.C; +>member : E.C +>E.C : E.C +>E : typeof E +>C : E.C + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).errors.txt new file mode 100644 index 0000000000000..22ee511f52182 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).errors.txt @@ -0,0 +1,22 @@ +checkOrderLateBoundMembers.ts(6,9): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(7,5): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(8,9): error TS2300: Duplicate identifier 'foo'. + + +==== checkOrderLateBoundMembers.ts (3 errors) ==== + // Resolving the name in a computed property name looks it up in the members + // of the enclosing interface. That must not late-bind those same members, + // or the accessors would not merge with the property when asked first. + const foo = "foo" + interface I { + get [foo](): number; + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + foo: number; + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + set [foo](value: number); + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).symbols new file mode 100644 index 0000000000000..5d947b8a60834 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).symbols @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + +interface I { +>I : Symbol(I, Decl(checkOrderLateBoundMembers.ts, 3, 17)) + + get [foo](): number; +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + + foo: number; +>foo : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) + + set [foo](value: number); +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) +>value : Symbol(value, Decl(checkOrderLateBoundMembers.ts, 7, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).types new file mode 100644 index 0000000000000..d6be33f1e73b4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : "foo" +>"foo" : "foo" + +interface I { + get [foo](): number; +>[foo] : number +>foo : "foo" + + foo: number; +>foo : number + + set [foo](value: number); +>[foo] : number +>foo : "foo" +>value : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).errors.txt new file mode 100644 index 0000000000000..22ee511f52182 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).errors.txt @@ -0,0 +1,22 @@ +checkOrderLateBoundMembers.ts(6,9): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(7,5): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(8,9): error TS2300: Duplicate identifier 'foo'. + + +==== checkOrderLateBoundMembers.ts (3 errors) ==== + // Resolving the name in a computed property name looks it up in the members + // of the enclosing interface. That must not late-bind those same members, + // or the accessors would not merge with the property when asked first. + const foo = "foo" + interface I { + get [foo](): number; + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + foo: number; + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + set [foo](value: number); + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).symbols new file mode 100644 index 0000000000000..5d947b8a60834 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).symbols @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + +interface I { +>I : Symbol(I, Decl(checkOrderLateBoundMembers.ts, 3, 17)) + + get [foo](): number; +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + + foo: number; +>foo : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) + + set [foo](value: number); +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) +>value : Symbol(value, Decl(checkOrderLateBoundMembers.ts, 7, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).types new file mode 100644 index 0000000000000..d6be33f1e73b4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : "foo" +>"foo" : "foo" + +interface I { + get [foo](): number; +>[foo] : number +>foo : "foo" + + foo: number; +>foo : number + + set [foo](value: number); +>[foo] : number +>foo : "foo" +>value : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).errors.txt new file mode 100644 index 0000000000000..22ee511f52182 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).errors.txt @@ -0,0 +1,22 @@ +checkOrderLateBoundMembers.ts(6,9): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(7,5): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(8,9): error TS2300: Duplicate identifier 'foo'. + + +==== checkOrderLateBoundMembers.ts (3 errors) ==== + // Resolving the name in a computed property name looks it up in the members + // of the enclosing interface. That must not late-bind those same members, + // or the accessors would not merge with the property when asked first. + const foo = "foo" + interface I { + get [foo](): number; + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + foo: number; + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + set [foo](value: number); + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).symbols new file mode 100644 index 0000000000000..5d947b8a60834 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).symbols @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + +interface I { +>I : Symbol(I, Decl(checkOrderLateBoundMembers.ts, 3, 17)) + + get [foo](): number; +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + + foo: number; +>foo : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) + + set [foo](value: number); +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) +>value : Symbol(value, Decl(checkOrderLateBoundMembers.ts, 7, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).types new file mode 100644 index 0000000000000..d6be33f1e73b4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : "foo" +>"foo" : "foo" + +interface I { + get [foo](): number; +>[foo] : number +>foo : "foo" + + foo: number; +>foo : number + + set [foo](value: number); +>[foo] : number +>foo : "foo" +>value : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..22ee511f52182 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).errors.txt @@ -0,0 +1,22 @@ +checkOrderLateBoundMembers.ts(6,9): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(7,5): error TS2300: Duplicate identifier 'foo'. +checkOrderLateBoundMembers.ts(8,9): error TS2300: Duplicate identifier 'foo'. + + +==== checkOrderLateBoundMembers.ts (3 errors) ==== + // Resolving the name in a computed property name looks it up in the members + // of the enclosing interface. That must not late-bind those same members, + // or the accessors would not merge with the property when asked first. + const foo = "foo" + interface I { + get [foo](): number; + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + foo: number; + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + set [foo](value: number); + ~~~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..5d947b8a60834 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).symbols @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + +interface I { +>I : Symbol(I, Decl(checkOrderLateBoundMembers.ts, 3, 17)) + + get [foo](): number; +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) + + foo: number; +>foo : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) + + set [foo](value: number); +>[foo] : Symbol(I.foo, Decl(checkOrderLateBoundMembers.ts, 5, 24), Decl(checkOrderLateBoundMembers.ts, 4, 13), Decl(checkOrderLateBoundMembers.ts, 6, 16)) +>foo : Symbol(foo, Decl(checkOrderLateBoundMembers.ts, 3, 5)) +>value : Symbol(value, Decl(checkOrderLateBoundMembers.ts, 7, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).types new file mode 100644 index 0000000000000..d6be33f1e73b4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/checkOrderLateBoundMembers.ts] //// + +=== checkOrderLateBoundMembers.ts === +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +>foo : "foo" +>"foo" : "foo" + +interface I { + get [foo](): number; +>[foo] : number +>foo : "foo" + + foo: number; +>foo : number + + set [foo](value: number); +>[foo] : number +>foo : "foo" +>value : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).js new file mode 100644 index 0000000000000..1d37a15bf23bd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +//// [index.js] +module.exports.i = function i() {} +module.exports.ii = module.exports.i; + + +//// [index.js] +"use strict"; +module.exports.i = function i() { }; +module.exports.ii = module.exports.i; + + +//// [index.d.ts] +export declare var i: () => void; +export declare var ii: () => void; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).symbols new file mode 100644 index 0000000000000..f14879d6cea9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).symbols @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 18)) + +module.exports.ii = module.exports.i; +>module.exports.ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).types new file mode 100644 index 0000000000000..f940f148c6541 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i = function i() {} : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void +>function i() {} : () => void +>i : () => void + +module.exports.ii = module.exports.i; +>module.exports.ii = module.exports.i : () => void +>module.exports.ii : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>ii : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).js new file mode 100644 index 0000000000000..1d37a15bf23bd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +//// [index.js] +module.exports.i = function i() {} +module.exports.ii = module.exports.i; + + +//// [index.js] +"use strict"; +module.exports.i = function i() { }; +module.exports.ii = module.exports.i; + + +//// [index.d.ts] +export declare var i: () => void; +export declare var ii: () => void; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).symbols new file mode 100644 index 0000000000000..f14879d6cea9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).symbols @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 18)) + +module.exports.ii = module.exports.i; +>module.exports.ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).types new file mode 100644 index 0000000000000..f940f148c6541 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i = function i() {} : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void +>function i() {} : () => void +>i : () => void + +module.exports.ii = module.exports.i; +>module.exports.ii = module.exports.i : () => void +>module.exports.ii : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>ii : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).js new file mode 100644 index 0000000000000..1d37a15bf23bd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +//// [index.js] +module.exports.i = function i() {} +module.exports.ii = module.exports.i; + + +//// [index.js] +"use strict"; +module.exports.i = function i() { }; +module.exports.ii = module.exports.i; + + +//// [index.d.ts] +export declare var i: () => void; +export declare var ii: () => void; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).symbols new file mode 100644 index 0000000000000..f14879d6cea9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).symbols @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 18)) + +module.exports.ii = module.exports.i; +>module.exports.ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).types new file mode 100644 index 0000000000000..f940f148c6541 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i = function i() {} : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void +>function i() {} : () => void +>i : () => void + +module.exports.ii = module.exports.i; +>module.exports.ii = module.exports.i : () => void +>module.exports.ii : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>ii : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).js new file mode 100644 index 0000000000000..1d37a15bf23bd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +//// [index.js] +module.exports.i = function i() {} +module.exports.ii = module.exports.i; + + +//// [index.js] +"use strict"; +module.exports.i = function i() { }; +module.exports.ii = module.exports.i; + + +//// [index.d.ts] +export declare var i: () => void; +export declare var ii: () => void; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..f14879d6cea9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).symbols @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 18)) + +module.exports.ii = module.exports.i; +>module.exports.ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>ii : Symbol(ii, Decl(index.js, 0, 34)) +>module.exports.i : Symbol(i, Decl(index.js, 0, 0)) +>module.exports : Symbol(exports, Decl(index.js, 0, 0)) +>module : Symbol(module, Decl(index.js, 0, 0)) +>exports : Symbol(exports, Decl(index.js, 0, 0)) +>i : Symbol(i, Decl(index.js, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).types new file mode 100644 index 0000000000000..f940f148c6541 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/checkOrderModuleExportsAlias.ts] //// + +=== index.js === +module.exports.i = function i() {} +>module.exports.i = function i() {} : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void +>function i() {} : () => void +>i : () => void + +module.exports.ii = module.exports.i; +>module.exports.ii = module.exports.i : () => void +>module.exports.ii : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>ii : () => void +>module.exports.i : () => void +>module.exports : typeof import(".") +>module : { exports: typeof import("."); } +>exports : typeof import(".") +>i : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).js new file mode 100644 index 0000000000000..749ae4044d77f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +//// [checkOrderParameterInTypeQuery.ts] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { + #a = 1; + test1() { + class C { + test1(a: C2): typeof a.#a { + return 1; + } + } + return new C().test1(this); + } +} + + +//// [checkOrderParameterInTypeQuery.js] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. +export class C2 { + #a = 1; + test1() { + class C { + test1(a) { + return 1; + } + } + return new C().test1(this); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).symbols new file mode 100644 index 0000000000000..7f3da2b79534f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).symbols @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + + #a = 1; +>#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) + + test1() { +>test1 : Symbol(C2.test1, Decl(checkOrderParameterInTypeQuery.ts, 5, 11)) + + class C { +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) + + test1(a: C2): typeof a.#a { +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) +>a.#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) + + return 1; + } + } + return new C().test1(this); +>new C().test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>this : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).types new file mode 100644 index 0000000000000..c7f091d02bcb0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : C2 + + #a = 1; +>#a : number +>1 : 1 + + test1() { +>test1 : () => number + + class C { +>C : C + + test1(a: C2): typeof a.#a { +>test1 : (a: C2) => typeof a.#a +>a : C2 +>a.#a : number +>a : C2 + + return 1; +>1 : 1 + } + } + return new C().test1(this); +>new C().test1(this) : number +>new C().test1 : (a: C2) => typeof a.#a +>new C() : C +>C : typeof C +>test1 : (a: C2) => typeof a.#a +>this : this + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).js new file mode 100644 index 0000000000000..749ae4044d77f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +//// [checkOrderParameterInTypeQuery.ts] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { + #a = 1; + test1() { + class C { + test1(a: C2): typeof a.#a { + return 1; + } + } + return new C().test1(this); + } +} + + +//// [checkOrderParameterInTypeQuery.js] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. +export class C2 { + #a = 1; + test1() { + class C { + test1(a) { + return 1; + } + } + return new C().test1(this); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).symbols new file mode 100644 index 0000000000000..7f3da2b79534f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).symbols @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + + #a = 1; +>#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) + + test1() { +>test1 : Symbol(C2.test1, Decl(checkOrderParameterInTypeQuery.ts, 5, 11)) + + class C { +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) + + test1(a: C2): typeof a.#a { +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) +>a.#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) + + return 1; + } + } + return new C().test1(this); +>new C().test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>this : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types new file mode 100644 index 0000000000000..c7f091d02bcb0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : C2 + + #a = 1; +>#a : number +>1 : 1 + + test1() { +>test1 : () => number + + class C { +>C : C + + test1(a: C2): typeof a.#a { +>test1 : (a: C2) => typeof a.#a +>a : C2 +>a.#a : number +>a : C2 + + return 1; +>1 : 1 + } + } + return new C().test1(this); +>new C().test1(this) : number +>new C().test1 : (a: C2) => typeof a.#a +>new C() : C +>C : typeof C +>test1 : (a: C2) => typeof a.#a +>this : this + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).js new file mode 100644 index 0000000000000..749ae4044d77f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +//// [checkOrderParameterInTypeQuery.ts] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { + #a = 1; + test1() { + class C { + test1(a: C2): typeof a.#a { + return 1; + } + } + return new C().test1(this); + } +} + + +//// [checkOrderParameterInTypeQuery.js] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. +export class C2 { + #a = 1; + test1() { + class C { + test1(a) { + return 1; + } + } + return new C().test1(this); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).symbols new file mode 100644 index 0000000000000..7f3da2b79534f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).symbols @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + + #a = 1; +>#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) + + test1() { +>test1 : Symbol(C2.test1, Decl(checkOrderParameterInTypeQuery.ts, 5, 11)) + + class C { +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) + + test1(a: C2): typeof a.#a { +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) +>a.#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) + + return 1; + } + } + return new C().test1(this); +>new C().test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>this : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).types new file mode 100644 index 0000000000000..c7f091d02bcb0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : C2 + + #a = 1; +>#a : number +>1 : 1 + + test1() { +>test1 : () => number + + class C { +>C : C + + test1(a: C2): typeof a.#a { +>test1 : (a: C2) => typeof a.#a +>a : C2 +>a.#a : number +>a : C2 + + return 1; +>1 : 1 + } + } + return new C().test1(this); +>new C().test1(this) : number +>new C().test1 : (a: C2) => typeof a.#a +>new C() : C +>C : typeof C +>test1 : (a: C2) => typeof a.#a +>this : this + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).js new file mode 100644 index 0000000000000..749ae4044d77f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +//// [checkOrderParameterInTypeQuery.ts] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { + #a = 1; + test1() { + class C { + test1(a: C2): typeof a.#a { + return 1; + } + } + return new C().test1(this); + } +} + + +//// [checkOrderParameterInTypeQuery.js] +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. +export class C2 { + #a = 1; + test1() { + class C { + test1(a) { + return 1; + } + } + return new C().test1(this); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..7f3da2b79534f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).symbols @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + + #a = 1; +>#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) + + test1() { +>test1 : Symbol(C2.test1, Decl(checkOrderParameterInTypeQuery.ts, 5, 11)) + + class C { +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) + + test1(a: C2): typeof a.#a { +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) +>C2 : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) +>a.#a : Symbol(C2.#a, Decl(checkOrderParameterInTypeQuery.ts, 4, 17)) +>a : Symbol(a, Decl(checkOrderParameterInTypeQuery.ts, 8, 18)) + + return 1; + } + } + return new C().test1(this); +>new C().test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>C : Symbol(C, Decl(checkOrderParameterInTypeQuery.ts, 6, 13)) +>test1 : Symbol(C.test1, Decl(checkOrderParameterInTypeQuery.ts, 7, 17)) +>this : Symbol(C2, Decl(checkOrderParameterInTypeQuery.ts, 0, 0)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types new file mode 100644 index 0000000000000..c7f091d02bcb0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/checkOrderParameterInTypeQuery.ts] //// + +=== checkOrderParameterInTypeQuery.ts === +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { +>C2 : C2 + + #a = 1; +>#a : number +>1 : 1 + + test1() { +>test1 : () => number + + class C { +>C : C + + test1(a: C2): typeof a.#a { +>test1 : (a: C2) => typeof a.#a +>a : C2 +>a.#a : number +>a : C2 + + return 1; +>1 : 1 + } + } + return new C().test1(this); +>new C().test1(this) : number +>new C().test1 : (a: C2) => typeof a.#a +>new C() : C +>C : typeof C +>test1 : (a: C2) => typeof a.#a +>this : this + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).errors.txt new file mode 100644 index 0000000000000..3fd3738f9b7f2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).errors.txt @@ -0,0 +1,36 @@ +join.ts(3,5): error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. + Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. + Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +recur.ts(3,9): error TS2536: Type 'number' cannot be used to index type 'Recur'. + + +==== recur.ts (1 errors) ==== + export type Recur = + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + ~~~~~~~~~~~~~~~~ +!!! error TS2536: Type 'number' cannot be used to index type 'Recur'. + +==== join.ts (1 errors) ==== + import { Recur } from "./recur"; + export function join(l: Recur[]): Recur { + return ['marker', ...l]; + ~~~~~~ +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. +!!! error TS2322: Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + } + +==== a.ts (0 errors) ==== + import { Recur } from "./recur"; + import { join } from "./join"; + function a(l: Recur[]): void { + const x: Recur | undefined = join(l); + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).symbols new file mode 100644 index 0000000000000..d9f42dc0817f8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).symbols @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) + + [...Recur[number][]]; +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + +=== join.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) + +export function join(l: Recur[]): Recur { +>join : Symbol(join, Decl(join.ts, 0, 32)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>l : Symbol(l, Decl(join.ts, 1, 24)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) + + return ['marker', ...l]; +>l : Symbol(l, Decl(join.ts, 1, 24)) +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +import { join } from "./join"; +>join : Symbol(join, Decl(a.ts, 1, 8)) + +function a(l: Recur[]): void { +>a : Symbol(a, Decl(a.ts, 1, 30)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) + + const x: Recur | undefined = join(l); +>x : Symbol(x, Decl(a.ts, 3, 9)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>join : Symbol(join, Decl(a.ts, 1, 8)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).types new file mode 100644 index 0000000000000..833609532a4c1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Recur + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + +=== join.ts === +import { Recur } from "./recur"; +>Recur : any + +export function join(l: Recur[]): Recur { +>join : (l: Recur[]) => Recur +>l : Recur[] + + return ['marker', ...l]; +>['marker', ...l] : [string, ...Recur[]] +>'marker' : "marker" +>...l : Recur +>l : Recur[] +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : any + +import { join } from "./join"; +>join : (l: Recur[]) => Recur + +function a(l: Recur[]): void { +>a : (l: Recur[]) => void +>l : Recur[] + + const x: Recur | undefined = join(l); +>x : Recur | undefined +>join(l) : Recur +>join : (l: Recur[]) => Recur +>l : Recur[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).errors.txt new file mode 100644 index 0000000000000..3fd3738f9b7f2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).errors.txt @@ -0,0 +1,36 @@ +join.ts(3,5): error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. + Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. + Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +recur.ts(3,9): error TS2536: Type 'number' cannot be used to index type 'Recur'. + + +==== recur.ts (1 errors) ==== + export type Recur = + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + ~~~~~~~~~~~~~~~~ +!!! error TS2536: Type 'number' cannot be used to index type 'Recur'. + +==== join.ts (1 errors) ==== + import { Recur } from "./recur"; + export function join(l: Recur[]): Recur { + return ['marker', ...l]; + ~~~~~~ +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. +!!! error TS2322: Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + } + +==== a.ts (0 errors) ==== + import { Recur } from "./recur"; + import { join } from "./join"; + function a(l: Recur[]): void { + const x: Recur | undefined = join(l); + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).symbols new file mode 100644 index 0000000000000..d9f42dc0817f8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).symbols @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) + + [...Recur[number][]]; +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + +=== join.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) + +export function join(l: Recur[]): Recur { +>join : Symbol(join, Decl(join.ts, 0, 32)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>l : Symbol(l, Decl(join.ts, 1, 24)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) + + return ['marker', ...l]; +>l : Symbol(l, Decl(join.ts, 1, 24)) +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +import { join } from "./join"; +>join : Symbol(join, Decl(a.ts, 1, 8)) + +function a(l: Recur[]): void { +>a : Symbol(a, Decl(a.ts, 1, 30)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) + + const x: Recur | undefined = join(l); +>x : Symbol(x, Decl(a.ts, 3, 9)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>join : Symbol(join, Decl(a.ts, 1, 8)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).types new file mode 100644 index 0000000000000..833609532a4c1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Recur + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + +=== join.ts === +import { Recur } from "./recur"; +>Recur : any + +export function join(l: Recur[]): Recur { +>join : (l: Recur[]) => Recur +>l : Recur[] + + return ['marker', ...l]; +>['marker', ...l] : [string, ...Recur[]] +>'marker' : "marker" +>...l : Recur +>l : Recur[] +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : any + +import { join } from "./join"; +>join : (l: Recur[]) => Recur + +function a(l: Recur[]): void { +>a : (l: Recur[]) => void +>l : Recur[] + + const x: Recur | undefined = join(l); +>x : Recur | undefined +>join(l) : Recur +>join : (l: Recur[]) => Recur +>l : Recur[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).errors.txt new file mode 100644 index 0000000000000..3fd3738f9b7f2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).errors.txt @@ -0,0 +1,36 @@ +join.ts(3,5): error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. + Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. + Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +recur.ts(3,9): error TS2536: Type 'number' cannot be used to index type 'Recur'. + + +==== recur.ts (1 errors) ==== + export type Recur = + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + ~~~~~~~~~~~~~~~~ +!!! error TS2536: Type 'number' cannot be used to index type 'Recur'. + +==== join.ts (1 errors) ==== + import { Recur } from "./recur"; + export function join(l: Recur[]): Recur { + return ['marker', ...l]; + ~~~~~~ +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. +!!! error TS2322: Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + } + +==== a.ts (0 errors) ==== + import { Recur } from "./recur"; + import { join } from "./join"; + function a(l: Recur[]): void { + const x: Recur | undefined = join(l); + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).symbols new file mode 100644 index 0000000000000..d9f42dc0817f8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).symbols @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) + + [...Recur[number][]]; +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + +=== join.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) + +export function join(l: Recur[]): Recur { +>join : Symbol(join, Decl(join.ts, 0, 32)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>l : Symbol(l, Decl(join.ts, 1, 24)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) + + return ['marker', ...l]; +>l : Symbol(l, Decl(join.ts, 1, 24)) +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +import { join } from "./join"; +>join : Symbol(join, Decl(a.ts, 1, 8)) + +function a(l: Recur[]): void { +>a : Symbol(a, Decl(a.ts, 1, 30)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) + + const x: Recur | undefined = join(l); +>x : Symbol(x, Decl(a.ts, 3, 9)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>join : Symbol(join, Decl(a.ts, 1, 8)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).types new file mode 100644 index 0000000000000..833609532a4c1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Recur + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + +=== join.ts === +import { Recur } from "./recur"; +>Recur : any + +export function join(l: Recur[]): Recur { +>join : (l: Recur[]) => Recur +>l : Recur[] + + return ['marker', ...l]; +>['marker', ...l] : [string, ...Recur[]] +>'marker' : "marker" +>...l : Recur +>l : Recur[] +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : any + +import { join } from "./join"; +>join : (l: Recur[]) => Recur + +function a(l: Recur[]): void { +>a : (l: Recur[]) => void +>l : Recur[] + + const x: Recur | undefined = join(l); +>x : Recur | undefined +>join(l) : Recur +>join : (l: Recur[]) => Recur +>l : Recur[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..3fd3738f9b7f2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).errors.txt @@ -0,0 +1,36 @@ +join.ts(3,5): error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. + Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. + Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +recur.ts(3,9): error TS2536: Type 'number' cannot be used to index type 'Recur'. + + +==== recur.ts (1 errors) ==== + export type Recur = + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + ~~~~~~~~~~~~~~~~ +!!! error TS2536: Type 'number' cannot be used to index type 'Recur'. + +==== join.ts (1 errors) ==== + import { Recur } from "./recur"; + export function join(l: Recur[]): Recur { + return ['marker', ...l]; + ~~~~~~ +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur'. +!!! error TS2322: Type '[string, ...Recur[]]' is not assignable to type 'Recur[number][]'. +!!! error TS2322: Type 'string | Recur' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type 'Recur[number] & (T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. +!!! error TS2322: Type 'string' is not assignable to type '(T extends unknown[] ? {} : { [K in keyof T]?: Recur | undefined; })[number]'. + } + +==== a.ts (0 errors) ==== + import { Recur } from "./recur"; + import { join } from "./join"; + function a(l: Recur[]): void { + const x: Recur | undefined = join(l); + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..d9f42dc0817f8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).symbols @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) +>K : Symbol(K, Decl(recur.ts, 1, 38)) + + [...Recur[number][]]; +>Recur : Symbol(Recur, Decl(recur.ts, 0, 0)) +>T : Symbol(T, Decl(recur.ts, 0, 18)) + +=== join.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) + +export function join(l: Recur[]): Recur { +>join : Symbol(join, Decl(join.ts, 0, 32)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>l : Symbol(l, Decl(join.ts, 1, 24)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) +>Recur : Symbol(Recur, Decl(join.ts, 0, 8)) +>T : Symbol(T, Decl(join.ts, 1, 21)) + + return ['marker', ...l]; +>l : Symbol(l, Decl(join.ts, 1, 24)) +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +import { join } from "./join"; +>join : Symbol(join, Decl(a.ts, 1, 8)) + +function a(l: Recur[]): void { +>a : Symbol(a, Decl(a.ts, 1, 30)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) + + const x: Recur | undefined = join(l); +>x : Symbol(x, Decl(a.ts, 3, 9)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) +>T : Symbol(T, Decl(a.ts, 2, 11)) +>join : Symbol(join, Decl(a.ts, 1, 8)) +>l : Symbol(l, Decl(a.ts, 2, 14)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).types new file mode 100644 index 0000000000000..833609532a4c1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts] //// + +=== recur.ts === +export type Recur = +>Recur : Recur + + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + +=== join.ts === +import { Recur } from "./recur"; +>Recur : any + +export function join(l: Recur[]): Recur { +>join : (l: Recur[]) => Recur +>l : Recur[] + + return ['marker', ...l]; +>['marker', ...l] : [string, ...Recur[]] +>'marker' : "marker" +>...l : Recur +>l : Recur[] +} + +=== a.ts === +import { Recur } from "./recur"; +>Recur : any + +import { join } from "./join"; +>join : (l: Recur[]) => Recur + +function a(l: Recur[]): void { +>a : (l: Recur[]) => void +>l : Recur[] + + const x: Recur | undefined = join(l); +>x : Recur | undefined +>join(l) : Recur +>join : (l: Recur[]) => Recur +>l : Recur[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js new file mode 100644 index 0000000000000..8d70e46a3bf67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js @@ -0,0 +1,84 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +//// [ma.js] +export { v as pa } from "./xa"; +export const ma = 1; + +//// [mb.js] +export { v as pb } from "./xb"; +export const mb = 1; + +//// [xa.js] +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [xb.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [ia.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [mb.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.mb = exports.pb = void 0; +var xb_1 = require("./xb"); +Object.defineProperty(exports, "pb", { enumerable: true, get: function () { return xb_1.v; } }); +exports.mb = 1; +//// [xa.js] +"use strict"; +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [ma.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ma = exports.pa = void 0; +var xa_1 = require("./xa"); +Object.defineProperty(exports, "pa", { enumerable: true, get: function () { return xa_1.v; } }); +exports.ma = 1; +//// [ia.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: { + v: {}; +}; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).symbols new file mode 100644 index 0000000000000..4359b0af3b06c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(ia.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(ia.js, 0, 0)) +>module : Symbol(module, Decl(ia.js, 0, 0)) +>exports : Symbol(exports, Decl(ia.js, 0, 0)) +>v : Symbol(v, Decl(ia.js, 2, 18)) +>M : Symbol(M, Decl(ia.js, 1, 5)) + +=== /ma.js === +export { v as pa } from "./xa"; +>v : Symbol(v, Decl(xa.js, 2, 18)) +>pa : Symbol(pa, Decl(ma.js, 0, 8)) + +export const ma = 1; +>ma : Symbol(ma, Decl(ma.js, 1, 12)) + +=== /mb.js === +export { v as pb } from "./xb"; +>v : Symbol(v, Decl(xb.js, 2, 18)) +>pb : Symbol(pb, Decl(mb.js, 0, 8)) + +export const mb = 1; +>mb : Symbol(mb, Decl(mb.js, 1, 12)) + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xa.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xa.js, 0, 0)) +>module : Symbol(module, Decl(xa.js, 0, 0)) +>exports : Symbol(exports, Decl(xa.js, 0, 0)) +>v : Symbol(v, Decl(xa.js, 2, 18)) +>M : Symbol(M, Decl(xa.js, 1, 5)) + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xb.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xb.js, 0, 0)) +>module : Symbol(module, Decl(xb.js, 0, 0)) +>exports : Symbol(exports, Decl(xb.js, 0, 0)) +>v : Symbol(v, Decl(xb.js, 2, 18)) +>M : Symbol(M, Decl(xb.js, 1, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types new file mode 100644 index 0000000000000..b82d88007b600 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : {} +>pa : {} + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : { pa: {}; ma: 1; } +>pb : { pa: {}; ma: 1; } + +export const mb = 1; +>mb : 1 +>1 : 1 + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./mb") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { v: {}; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } +>M : typeof import("./mb") + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).js b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).js new file mode 100644 index 0000000000000..8d70e46a3bf67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).js @@ -0,0 +1,84 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +//// [ma.js] +export { v as pa } from "./xa"; +export const ma = 1; + +//// [mb.js] +export { v as pb } from "./xb"; +export const mb = 1; + +//// [xa.js] +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [xb.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [ia.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [mb.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.mb = exports.pb = void 0; +var xb_1 = require("./xb"); +Object.defineProperty(exports, "pb", { enumerable: true, get: function () { return xb_1.v; } }); +exports.mb = 1; +//// [xa.js] +"use strict"; +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [ma.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ma = exports.pa = void 0; +var xa_1 = require("./xa"); +Object.defineProperty(exports, "pa", { enumerable: true, get: function () { return xa_1.v; } }); +exports.ma = 1; +//// [ia.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: { + v: {}; +}; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).symbols new file mode 100644 index 0000000000000..4359b0af3b06c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(ia.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(ia.js, 0, 0)) +>module : Symbol(module, Decl(ia.js, 0, 0)) +>exports : Symbol(exports, Decl(ia.js, 0, 0)) +>v : Symbol(v, Decl(ia.js, 2, 18)) +>M : Symbol(M, Decl(ia.js, 1, 5)) + +=== /ma.js === +export { v as pa } from "./xa"; +>v : Symbol(v, Decl(xa.js, 2, 18)) +>pa : Symbol(pa, Decl(ma.js, 0, 8)) + +export const ma = 1; +>ma : Symbol(ma, Decl(ma.js, 1, 12)) + +=== /mb.js === +export { v as pb } from "./xb"; +>v : Symbol(v, Decl(xb.js, 2, 18)) +>pb : Symbol(pb, Decl(mb.js, 0, 8)) + +export const mb = 1; +>mb : Symbol(mb, Decl(mb.js, 1, 12)) + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xa.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xa.js, 0, 0)) +>module : Symbol(module, Decl(xa.js, 0, 0)) +>exports : Symbol(exports, Decl(xa.js, 0, 0)) +>v : Symbol(v, Decl(xa.js, 2, 18)) +>M : Symbol(M, Decl(xa.js, 1, 5)) + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xb.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xb.js, 0, 0)) +>module : Symbol(module, Decl(xb.js, 0, 0)) +>exports : Symbol(exports, Decl(xb.js, 0, 0)) +>v : Symbol(v, Decl(xb.js, 2, 18)) +>M : Symbol(M, Decl(xb.js, 1, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types new file mode 100644 index 0000000000000..b82d88007b600 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : {} +>pa : {} + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : { pa: {}; ma: 1; } +>pb : { pa: {}; ma: 1; } + +export const mb = 1; +>mb : 1 +>1 : 1 + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./mb") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { v: {}; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } +>M : typeof import("./mb") + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).js new file mode 100644 index 0000000000000..8d70e46a3bf67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).js @@ -0,0 +1,84 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +//// [ma.js] +export { v as pa } from "./xa"; +export const ma = 1; + +//// [mb.js] +export { v as pb } from "./xb"; +export const mb = 1; + +//// [xa.js] +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [xb.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [ia.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [mb.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.mb = exports.pb = void 0; +var xb_1 = require("./xb"); +Object.defineProperty(exports, "pb", { enumerable: true, get: function () { return xb_1.v; } }); +exports.mb = 1; +//// [xa.js] +"use strict"; +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [ma.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ma = exports.pa = void 0; +var xa_1 = require("./xa"); +Object.defineProperty(exports, "pa", { enumerable: true, get: function () { return xa_1.v; } }); +exports.ma = 1; +//// [ia.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: { + v: {}; +}; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).symbols new file mode 100644 index 0000000000000..4359b0af3b06c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(ia.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(ia.js, 0, 0)) +>module : Symbol(module, Decl(ia.js, 0, 0)) +>exports : Symbol(exports, Decl(ia.js, 0, 0)) +>v : Symbol(v, Decl(ia.js, 2, 18)) +>M : Symbol(M, Decl(ia.js, 1, 5)) + +=== /ma.js === +export { v as pa } from "./xa"; +>v : Symbol(v, Decl(xa.js, 2, 18)) +>pa : Symbol(pa, Decl(ma.js, 0, 8)) + +export const ma = 1; +>ma : Symbol(ma, Decl(ma.js, 1, 12)) + +=== /mb.js === +export { v as pb } from "./xb"; +>v : Symbol(v, Decl(xb.js, 2, 18)) +>pb : Symbol(pb, Decl(mb.js, 0, 8)) + +export const mb = 1; +>mb : Symbol(mb, Decl(mb.js, 1, 12)) + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xa.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xa.js, 0, 0)) +>module : Symbol(module, Decl(xa.js, 0, 0)) +>exports : Symbol(exports, Decl(xa.js, 0, 0)) +>v : Symbol(v, Decl(xa.js, 2, 18)) +>M : Symbol(M, Decl(xa.js, 1, 5)) + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xb.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xb.js, 0, 0)) +>module : Symbol(module, Decl(xb.js, 0, 0)) +>exports : Symbol(exports, Decl(xb.js, 0, 0)) +>v : Symbol(v, Decl(xb.js, 2, 18)) +>M : Symbol(M, Decl(xb.js, 1, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types new file mode 100644 index 0000000000000..b82d88007b600 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : {} +>pa : {} + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : { pa: {}; ma: 1; } +>pb : { pa: {}; ma: 1; } + +export const mb = 1; +>mb : 1 +>1 : 1 + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./mb") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { v: {}; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } +>M : typeof import("./mb") + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).js new file mode 100644 index 0000000000000..8d70e46a3bf67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).js @@ -0,0 +1,84 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +//// [ma.js] +export { v as pa } from "./xa"; +export const ma = 1; + +//// [mb.js] +export { v as pb } from "./xb"; +export const mb = 1; + +//// [xa.js] +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [xb.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +//// [ia.js] +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [mb.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.mb = exports.pb = void 0; +var xb_1 = require("./xb"); +Object.defineProperty(exports, "pb", { enumerable: true, get: function () { return xb_1.v; } }); +exports.mb = 1; +//// [xa.js] +"use strict"; +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; +//// [ma.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ma = exports.pa = void 0; +var xa_1 = require("./xa"); +Object.defineProperty(exports, "pa", { enumerable: true, get: function () { return xa_1.v; } }); +exports.ma = 1; +//// [ia.js] +"use strict"; +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + + +//// [xb.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: { + v: {}; +}; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: {}; + ma: 1; + }; +}; +export = _exports; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..4359b0af3b06c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(ia.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(ia.js, 0, 0)) +>module : Symbol(module, Decl(ia.js, 0, 0)) +>exports : Symbol(exports, Decl(ia.js, 0, 0)) +>v : Symbol(v, Decl(ia.js, 2, 18)) +>M : Symbol(M, Decl(ia.js, 1, 5)) + +=== /ma.js === +export { v as pa } from "./xa"; +>v : Symbol(v, Decl(xa.js, 2, 18)) +>pa : Symbol(pa, Decl(ma.js, 0, 8)) + +export const ma = 1; +>ma : Symbol(ma, Decl(ma.js, 1, 12)) + +=== /mb.js === +export { v as pb } from "./xb"; +>v : Symbol(v, Decl(xb.js, 2, 18)) +>pb : Symbol(pb, Decl(mb.js, 0, 8)) + +export const mb = 1; +>mb : Symbol(mb, Decl(mb.js, 1, 12)) + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xa.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xa.js, 0, 0)) +>module : Symbol(module, Decl(xa.js, 0, 0)) +>exports : Symbol(exports, Decl(xa.js, 0, 0)) +>v : Symbol(v, Decl(xa.js, 2, 18)) +>M : Symbol(M, Decl(xa.js, 1, 5)) + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : Symbol(M, Decl(xb.js, 1, 5)) + +module.exports = { v: { ...M } }; +>module.exports : Symbol(exports, Decl(xb.js, 0, 0)) +>module : Symbol(module, Decl(xb.js, 0, 0)) +>exports : Symbol(exports, Decl(xb.js, 0, 0)) +>v : Symbol(v, Decl(xb.js, 2, 18)) +>M : Symbol(M, Decl(xb.js, 1, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types new file mode 100644 index 0000000000000..b82d88007b600 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/checkOrderSpreadCycle.ts] //// + +=== /ia.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : {} +>pa : {} + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : { pa: {}; ma: 1; } +>pb : { pa: {}; ma: 1; } + +export const mb = 1; +>mb : 1 +>1 : 1 + +=== /xa.js === +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./mb") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { v: {}; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } +>M : typeof import("./mb") + +=== /xb.js === +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +>M : typeof import("./ma") +>(null) : any + +module.exports = { v: { ...M } }; +>module.exports = { v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } +>M : typeof import("./ma") + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).errors.txt new file mode 100644 index 0000000000000..a547413430b10 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).errors.txt @@ -0,0 +1,44 @@ +a.ts(2,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +a.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly infinite. +b.ts(2,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +b.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== lib.ts (0 errors) ==== + export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +==== a.ts (2 errors) ==== + import { Recur } from "./lib"; + export let a: Recur<5, "a">; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + +==== b.ts (2 errors) ==== + import { Recur } from "./lib"; + export let b: Recur<5, "a">; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + +==== c.ts (0 errors) ==== + class T { + declare a: A; + declare b: any; + } + class L extends T {} + export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).js new file mode 100644 index 0000000000000..854a59f625301 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).js @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +//// [lib.ts] +export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +//// [a.ts] +import { Recur } from "./lib"; +export let a: Recur<5, "a">; + +//// [b.ts] +import { Recur } from "./lib"; +export let b: Recur<5, "a">; + +//// [c.ts] +class T { + declare a: A; + declare b: any; +} +class L extends T {} +export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } +} + + +//// [lib.js] +export {}; +//// [a.js] +export let a; +//// [b.js] +export let b; +//// [c.js] +class T { +} +class L extends T { +} +export class X extends L { + m() { + this.a; + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).symbols new file mode 100644 index 0000000000000..c98e5279b2d56 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).symbols @@ -0,0 +1,90 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +=== lib.ts === +export type Dec = +>Dec : Symbol(Dec, Decl(lib.ts, 0, 0)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : +>N : Symbol(N, Decl(lib.ts, 0, 16)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 2 ? any : +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 1 ? 0 : 0; +>N : Symbol(N, Decl(lib.ts, 0, 16)) + +export type Recur = +>Recur : Symbol(Recur, Decl(lib.ts, 3, 24)) +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) + + N extends 0 ? S : Recur, `${S}_${S}`>; +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) +>Recur : Symbol(Recur, Decl(lib.ts, 3, 24)) +>Dec : Symbol(Dec, Decl(lib.ts, 0, 0)) +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) + +=== a.ts === +import { Recur } from "./lib"; +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +export let a: Recur<5, "a">; +>a : Symbol(a, Decl(a.ts, 1, 10)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +=== b.ts === +import { Recur } from "./lib"; +>Recur : Symbol(Recur, Decl(b.ts, 0, 8)) + +export let b: Recur<5, "a">; +>b : Symbol(b, Decl(b.ts, 1, 10)) +>Recur : Symbol(Recur, Decl(b.ts, 0, 8)) + +=== c.ts === +class T { +>T : Symbol(T, Decl(c.ts, 0, 0)) +>A : Symbol(A, Decl(c.ts, 0, 8)) + + declare a: A; +>a : Symbol(T.a, Decl(c.ts, 0, 12)) +>A : Symbol(A, Decl(c.ts, 0, 8)) + + declare b: any; +>b : Symbol(T.b, Decl(c.ts, 1, 17)) +} +class L extends T {} +>L : Symbol(L, Decl(c.ts, 3, 1)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) +>a : Symbol(a, Decl(c.ts, 4, 20)) +>b : Symbol(b, Decl(c.ts, 4, 34)) +>T : Symbol(T, Decl(c.ts, 0, 0)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) + +export class X extends L { +>X : Symbol(X, Decl(c.ts, 4, 70)) +>L : Symbol(L, Decl(c.ts, 3, 1)) +>X : Symbol(X, Decl(c.ts, 4, 70)) + + declare a: 'a' | 'b'; +>a : Symbol(X.a, Decl(c.ts, 5, 29)) + + declare b: number; +>b : Symbol(X.b, Decl(c.ts, 6, 25)) + + m() { +>m : Symbol(X.m, Decl(c.ts, 7, 22)) + + this.a; +>this.a : Symbol(X.a, Decl(c.ts, 5, 29)) +>this : Symbol(X, Decl(c.ts, 4, 70)) +>a : Symbol(X.a, Decl(c.ts, 5, 29)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).types new file mode 100644 index 0000000000000..8c9592f59bc30 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +=== lib.ts === +export type Dec = +>Dec : Dec + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = +>Recur : Recur + + N extends 0 ? S : Recur, `${S}_${S}`>; + +=== a.ts === +import { Recur } from "./lib"; +>Recur : any + +export let a: Recur<5, "a">; +>a : any + +=== b.ts === +import { Recur } from "./lib"; +>Recur : any + +export let b: Recur<5, "a">; +>b : any + +=== c.ts === +class T { +>T : T + + declare a: A; +>a : A + + declare b: any; +>b : any +} +class L extends T {} +>L : L +>a : "a" | "b" +>b : any +>T : T + +export class X extends L { +>X : X +>L : L + + declare a: 'a' | 'b'; +>a : "a" | "b" + + declare b: number; +>b : number + + m() { +>m : () => void + + this.a; +>this.a : "a" | "b" +>this : this +>a : "a" | "b" + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt new file mode 100644 index 0000000000000..a547413430b10 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt @@ -0,0 +1,44 @@ +a.ts(2,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +a.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly infinite. +b.ts(2,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +b.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== lib.ts (0 errors) ==== + export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +==== a.ts (2 errors) ==== + import { Recur } from "./lib"; + export let a: Recur<5, "a">; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + +==== b.ts (2 errors) ==== + import { Recur } from "./lib"; + export let b: Recur<5, "a">; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + +==== c.ts (0 errors) ==== + class T { + declare a: A; + declare b: any; + } + class L extends T {} + export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).js b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).js new file mode 100644 index 0000000000000..854a59f625301 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).js @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +//// [lib.ts] +export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +//// [a.ts] +import { Recur } from "./lib"; +export let a: Recur<5, "a">; + +//// [b.ts] +import { Recur } from "./lib"; +export let b: Recur<5, "a">; + +//// [c.ts] +class T { + declare a: A; + declare b: any; +} +class L extends T {} +export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } +} + + +//// [lib.js] +export {}; +//// [a.js] +export let a; +//// [b.js] +export let b; +//// [c.js] +class T { +} +class L extends T { +} +export class X extends L { + m() { + this.a; + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).symbols new file mode 100644 index 0000000000000..c98e5279b2d56 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).symbols @@ -0,0 +1,90 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +=== lib.ts === +export type Dec = +>Dec : Symbol(Dec, Decl(lib.ts, 0, 0)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : +>N : Symbol(N, Decl(lib.ts, 0, 16)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 2 ? any : +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 1 ? 0 : 0; +>N : Symbol(N, Decl(lib.ts, 0, 16)) + +export type Recur = +>Recur : Symbol(Recur, Decl(lib.ts, 3, 24)) +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) + + N extends 0 ? S : Recur, `${S}_${S}`>; +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) +>Recur : Symbol(Recur, Decl(lib.ts, 3, 24)) +>Dec : Symbol(Dec, Decl(lib.ts, 0, 0)) +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) + +=== a.ts === +import { Recur } from "./lib"; +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +export let a: Recur<5, "a">; +>a : Symbol(a, Decl(a.ts, 1, 10)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +=== b.ts === +import { Recur } from "./lib"; +>Recur : Symbol(Recur, Decl(b.ts, 0, 8)) + +export let b: Recur<5, "a">; +>b : Symbol(b, Decl(b.ts, 1, 10)) +>Recur : Symbol(Recur, Decl(b.ts, 0, 8)) + +=== c.ts === +class T { +>T : Symbol(T, Decl(c.ts, 0, 0)) +>A : Symbol(A, Decl(c.ts, 0, 8)) + + declare a: A; +>a : Symbol(T.a, Decl(c.ts, 0, 12)) +>A : Symbol(A, Decl(c.ts, 0, 8)) + + declare b: any; +>b : Symbol(T.b, Decl(c.ts, 1, 17)) +} +class L extends T {} +>L : Symbol(L, Decl(c.ts, 3, 1)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) +>a : Symbol(a, Decl(c.ts, 4, 20)) +>b : Symbol(b, Decl(c.ts, 4, 34)) +>T : Symbol(T, Decl(c.ts, 0, 0)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) + +export class X extends L { +>X : Symbol(X, Decl(c.ts, 4, 70)) +>L : Symbol(L, Decl(c.ts, 3, 1)) +>X : Symbol(X, Decl(c.ts, 4, 70)) + + declare a: 'a' | 'b'; +>a : Symbol(X.a, Decl(c.ts, 5, 29)) + + declare b: number; +>b : Symbol(X.b, Decl(c.ts, 6, 25)) + + m() { +>m : Symbol(X.m, Decl(c.ts, 7, 22)) + + this.a; +>this.a : Symbol(X.a, Decl(c.ts, 5, 29)) +>this : Symbol(X, Decl(c.ts, 4, 70)) +>a : Symbol(X.a, Decl(c.ts, 5, 29)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).types new file mode 100644 index 0000000000000..8c9592f59bc30 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +=== lib.ts === +export type Dec = +>Dec : Dec + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = +>Recur : Recur + + N extends 0 ? S : Recur, `${S}_${S}`>; + +=== a.ts === +import { Recur } from "./lib"; +>Recur : any + +export let a: Recur<5, "a">; +>a : any + +=== b.ts === +import { Recur } from "./lib"; +>Recur : any + +export let b: Recur<5, "a">; +>b : any + +=== c.ts === +class T { +>T : T + + declare a: A; +>a : A + + declare b: any; +>b : any +} +class L extends T {} +>L : L +>a : "a" | "b" +>b : any +>T : T + +export class X extends L { +>X : X +>L : L + + declare a: 'a' | 'b'; +>a : "a" | "b" + + declare b: number; +>b : number + + m() { +>m : () => void + + this.a; +>this.a : "a" | "b" +>this : this +>a : "a" | "b" + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..a547413430b10 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt @@ -0,0 +1,44 @@ +a.ts(2,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +a.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly infinite. +b.ts(2,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +b.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== lib.ts (0 errors) ==== + export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +==== a.ts (2 errors) ==== + import { Recur } from "./lib"; + export let a: Recur<5, "a">; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + +==== b.ts (2 errors) ==== + import { Recur } from "./lib"; + export let b: Recur<5, "a">; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + +==== c.ts (0 errors) ==== + class T { + declare a: A; + declare b: any; + } + class L extends T {} + export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).js new file mode 100644 index 0000000000000..854a59f625301 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).js @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +//// [lib.ts] +export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +//// [a.ts] +import { Recur } from "./lib"; +export let a: Recur<5, "a">; + +//// [b.ts] +import { Recur } from "./lib"; +export let b: Recur<5, "a">; + +//// [c.ts] +class T { + declare a: A; + declare b: any; +} +class L extends T {} +export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } +} + + +//// [lib.js] +export {}; +//// [a.js] +export let a; +//// [b.js] +export let b; +//// [c.js] +class T { +} +class L extends T { +} +export class X extends L { + m() { + this.a; + } +} diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c98e5279b2d56 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).symbols @@ -0,0 +1,90 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +=== lib.ts === +export type Dec = +>Dec : Symbol(Dec, Decl(lib.ts, 0, 0)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : +>N : Symbol(N, Decl(lib.ts, 0, 16)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 2 ? any : +>N : Symbol(N, Decl(lib.ts, 0, 16)) + + N extends 1 ? 0 : 0; +>N : Symbol(N, Decl(lib.ts, 0, 16)) + +export type Recur = +>Recur : Symbol(Recur, Decl(lib.ts, 3, 24)) +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) + + N extends 0 ? S : Recur, `${S}_${S}`>; +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) +>Recur : Symbol(Recur, Decl(lib.ts, 3, 24)) +>Dec : Symbol(Dec, Decl(lib.ts, 0, 0)) +>N : Symbol(N, Decl(lib.ts, 4, 18)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) +>S : Symbol(S, Decl(lib.ts, 4, 35)) + +=== a.ts === +import { Recur } from "./lib"; +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +export let a: Recur<5, "a">; +>a : Symbol(a, Decl(a.ts, 1, 10)) +>Recur : Symbol(Recur, Decl(a.ts, 0, 8)) + +=== b.ts === +import { Recur } from "./lib"; +>Recur : Symbol(Recur, Decl(b.ts, 0, 8)) + +export let b: Recur<5, "a">; +>b : Symbol(b, Decl(b.ts, 1, 10)) +>Recur : Symbol(Recur, Decl(b.ts, 0, 8)) + +=== c.ts === +class T { +>T : Symbol(T, Decl(c.ts, 0, 0)) +>A : Symbol(A, Decl(c.ts, 0, 8)) + + declare a: A; +>a : Symbol(T.a, Decl(c.ts, 0, 12)) +>A : Symbol(A, Decl(c.ts, 0, 8)) + + declare b: any; +>b : Symbol(T.b, Decl(c.ts, 1, 17)) +} +class L extends T {} +>L : Symbol(L, Decl(c.ts, 3, 1)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) +>a : Symbol(a, Decl(c.ts, 4, 20)) +>b : Symbol(b, Decl(c.ts, 4, 34)) +>T : Symbol(T, Decl(c.ts, 0, 0)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) +>RT : Symbol(RT, Decl(c.ts, 4, 8)) + +export class X extends L { +>X : Symbol(X, Decl(c.ts, 4, 70)) +>L : Symbol(L, Decl(c.ts, 3, 1)) +>X : Symbol(X, Decl(c.ts, 4, 70)) + + declare a: 'a' | 'b'; +>a : Symbol(X.a, Decl(c.ts, 5, 29)) + + declare b: number; +>b : Symbol(X.b, Decl(c.ts, 6, 25)) + + m() { +>m : Symbol(X.m, Decl(c.ts, 7, 22)) + + this.a; +>this.a : Symbol(X.a, Decl(c.ts, 5, 29)) +>this : Symbol(X, Decl(c.ts, 4, 70)) +>a : Symbol(X.a, Decl(c.ts, 5, 29)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).types new file mode 100644 index 0000000000000..8c9592f59bc30 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/checkOrderStableInstantiationErrors.ts] //// + +=== lib.ts === +export type Dec = +>Dec : Dec + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = +>Recur : Recur + + N extends 0 ? S : Recur, `${S}_${S}`>; + +=== a.ts === +import { Recur } from "./lib"; +>Recur : any + +export let a: Recur<5, "a">; +>a : any + +=== b.ts === +import { Recur } from "./lib"; +>Recur : any + +export let b: Recur<5, "a">; +>b : any + +=== c.ts === +class T { +>T : T + + declare a: A; +>a : A + + declare b: any; +>b : any +} +class L extends T {} +>L : L +>a : "a" | "b" +>b : any +>T : T + +export class X extends L { +>X : X +>L : L + + declare a: 'a' | 'b'; +>a : "a" | "b" + + declare b: number; +>b : number + + m() { +>m : () => void + + this.a; +>this.a : "a" | "b" +>this : this +>a : "a" | "b" + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).errors.txt new file mode 100644 index 0000000000000..9254be443a6c1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).errors.txt @@ -0,0 +1,41 @@ +circularAccessorAnnotations.ts(2,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. +circularAccessorAnnotations.ts(6,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. +circularAccessorAnnotations.ts(15,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. +circularAccessorAnnotations.ts(19,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + + +==== circularAccessorAnnotations.ts (4 errors) ==== + declare const c1: { + get foo(): typeof c1.foo; + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + declare const c2: { + set foo(value: typeof c2.foo); + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + declare const c3: { + get foo(): string; + set foo(value: typeof c3.foo); + } + + type T1 = { + get foo(): T1["foo"]; + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + type T2 = { + set foo(value: T2["foo"]); + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + type T3 = { + get foo(): string; + set foo(value: T3["foo"]); + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).js new file mode 100644 index 0000000000000..5f976ec06b212 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).js @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/circularAccessorAnnotations.ts] //// + +//// [circularAccessorAnnotations.ts] +declare const c1: { + get foo(): typeof c1.foo; +} + +declare const c2: { + set foo(value: typeof c2.foo); +} + +declare const c3: { + get foo(): string; + set foo(value: typeof c3.foo); +} + +type T1 = { + get foo(): T1["foo"]; +} + +type T2 = { + set foo(value: T2["foo"]); +} + +type T3 = { + get foo(): string; + set foo(value: T3["foo"]); +} + + +//// [circularAccessorAnnotations.js] +"use strict"; + + +//// [circularAccessorAnnotations.d.ts] +declare const c1: { + get foo(): typeof c1.foo; +}; +declare const c2: { + set foo(value: typeof c2.foo); +}; +declare const c3: { + get foo(): string; + set foo(value: typeof c3.foo); +}; +type T1 = { + get foo(): T1["foo"]; +}; +type T2 = { + set foo(value: T2["foo"]); +}; +type T3 = { + get foo(): string; + set foo(value: T3["foo"]); +}; diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).symbols new file mode 100644 index 0000000000000..d95b8cec0782f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).symbols @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/circularAccessorAnnotations.ts] //// + +=== circularAccessorAnnotations.ts === +declare const c1: { +>c1 : Symbol(c1, Decl(circularAccessorAnnotations.ts, 0, 13)) + + get foo(): typeof c1.foo; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 0, 19)) +>c1.foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 0, 19)) +>c1 : Symbol(c1, Decl(circularAccessorAnnotations.ts, 0, 13)) +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 0, 19)) +} + +declare const c2: { +>c2 : Symbol(c2, Decl(circularAccessorAnnotations.ts, 4, 13)) + + set foo(value: typeof c2.foo); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 4, 19)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 5, 12)) +>c2.foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 4, 19)) +>c2 : Symbol(c2, Decl(circularAccessorAnnotations.ts, 4, 13)) +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 4, 19)) +} + +declare const c3: { +>c3 : Symbol(c3, Decl(circularAccessorAnnotations.ts, 8, 13)) + + get foo(): string; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) + + set foo(value: typeof c3.foo); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 10, 12)) +>c3.foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) +>c3 : Symbol(c3, Decl(circularAccessorAnnotations.ts, 8, 13)) +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) +} + +type T1 = { +>T1 : Symbol(T1, Decl(circularAccessorAnnotations.ts, 11, 1)) + + get foo(): T1["foo"]; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 13, 11)) +>T1 : Symbol(T1, Decl(circularAccessorAnnotations.ts, 11, 1)) +} + +type T2 = { +>T2 : Symbol(T2, Decl(circularAccessorAnnotations.ts, 15, 1)) + + set foo(value: T2["foo"]); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 17, 11)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 18, 12)) +>T2 : Symbol(T2, Decl(circularAccessorAnnotations.ts, 15, 1)) +} + +type T3 = { +>T3 : Symbol(T3, Decl(circularAccessorAnnotations.ts, 19, 1)) + + get foo(): string; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22)) + + set foo(value: T3["foo"]); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 23, 12)) +>T3 : Symbol(T3, Decl(circularAccessorAnnotations.ts, 19, 1)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).types new file mode 100644 index 0000000000000..2b01358a33dca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/circularAccessorAnnotations.ts] //// + +=== circularAccessorAnnotations.ts === +declare const c1: { +>c1 : { readonly foo: typeof c1.foo; } + + get foo(): typeof c1.foo; +>foo : any +>c1.foo : any +>c1 : { readonly foo: typeof c1.foo; } +>foo : any +} + +declare const c2: { +>c2 : { foo: typeof c2.foo; } + + set foo(value: typeof c2.foo); +>foo : any +>value : any +>c2.foo : any +>c2 : { foo: typeof c2.foo; } +>foo : any +} + +declare const c3: { +>c3 : { foo: string; } + + get foo(): string; +>foo : string + + set foo(value: typeof c3.foo); +>foo : string +>value : string +>c3.foo : string +>c3 : { foo: string; } +>foo : string +} + +type T1 = { +>T1 : T1 + + get foo(): T1["foo"]; +>foo : any +} + +type T2 = { +>T2 : T2 + + set foo(value: T2["foo"]); +>foo : any +>value : any +} + +type T3 = { +>T3 : T3 + + get foo(): string; +>foo : string + + set foo(value: T3["foo"]); +>foo : string +>value : string +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..9254be443a6c1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).errors.txt @@ -0,0 +1,41 @@ +circularAccessorAnnotations.ts(2,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. +circularAccessorAnnotations.ts(6,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. +circularAccessorAnnotations.ts(15,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. +circularAccessorAnnotations.ts(19,9): error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + + +==== circularAccessorAnnotations.ts (4 errors) ==== + declare const c1: { + get foo(): typeof c1.foo; + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + declare const c2: { + set foo(value: typeof c2.foo); + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + declare const c3: { + get foo(): string; + set foo(value: typeof c3.foo); + } + + type T1 = { + get foo(): T1["foo"]; + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + type T2 = { + set foo(value: T2["foo"]); + ~~~ +!!! error TS2502: 'foo' is referenced directly or indirectly in its own type annotation. + } + + type T3 = { + get foo(): string; + set foo(value: T3["foo"]); + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).js new file mode 100644 index 0000000000000..5f976ec06b212 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).js @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/circularAccessorAnnotations.ts] //// + +//// [circularAccessorAnnotations.ts] +declare const c1: { + get foo(): typeof c1.foo; +} + +declare const c2: { + set foo(value: typeof c2.foo); +} + +declare const c3: { + get foo(): string; + set foo(value: typeof c3.foo); +} + +type T1 = { + get foo(): T1["foo"]; +} + +type T2 = { + set foo(value: T2["foo"]); +} + +type T3 = { + get foo(): string; + set foo(value: T3["foo"]); +} + + +//// [circularAccessorAnnotations.js] +"use strict"; + + +//// [circularAccessorAnnotations.d.ts] +declare const c1: { + get foo(): typeof c1.foo; +}; +declare const c2: { + set foo(value: typeof c2.foo); +}; +declare const c3: { + get foo(): string; + set foo(value: typeof c3.foo); +}; +type T1 = { + get foo(): T1["foo"]; +}; +type T2 = { + set foo(value: T2["foo"]); +}; +type T3 = { + get foo(): string; + set foo(value: T3["foo"]); +}; diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..d95b8cec0782f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).symbols @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/circularAccessorAnnotations.ts] //// + +=== circularAccessorAnnotations.ts === +declare const c1: { +>c1 : Symbol(c1, Decl(circularAccessorAnnotations.ts, 0, 13)) + + get foo(): typeof c1.foo; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 0, 19)) +>c1.foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 0, 19)) +>c1 : Symbol(c1, Decl(circularAccessorAnnotations.ts, 0, 13)) +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 0, 19)) +} + +declare const c2: { +>c2 : Symbol(c2, Decl(circularAccessorAnnotations.ts, 4, 13)) + + set foo(value: typeof c2.foo); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 4, 19)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 5, 12)) +>c2.foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 4, 19)) +>c2 : Symbol(c2, Decl(circularAccessorAnnotations.ts, 4, 13)) +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 4, 19)) +} + +declare const c3: { +>c3 : Symbol(c3, Decl(circularAccessorAnnotations.ts, 8, 13)) + + get foo(): string; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) + + set foo(value: typeof c3.foo); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 10, 12)) +>c3.foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) +>c3 : Symbol(c3, Decl(circularAccessorAnnotations.ts, 8, 13)) +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 8, 19), Decl(circularAccessorAnnotations.ts, 9, 22)) +} + +type T1 = { +>T1 : Symbol(T1, Decl(circularAccessorAnnotations.ts, 11, 1)) + + get foo(): T1["foo"]; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 13, 11)) +>T1 : Symbol(T1, Decl(circularAccessorAnnotations.ts, 11, 1)) +} + +type T2 = { +>T2 : Symbol(T2, Decl(circularAccessorAnnotations.ts, 15, 1)) + + set foo(value: T2["foo"]); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 17, 11)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 18, 12)) +>T2 : Symbol(T2, Decl(circularAccessorAnnotations.ts, 15, 1)) +} + +type T3 = { +>T3 : Symbol(T3, Decl(circularAccessorAnnotations.ts, 19, 1)) + + get foo(): string; +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22)) + + set foo(value: T3["foo"]); +>foo : Symbol(foo, Decl(circularAccessorAnnotations.ts, 21, 11), Decl(circularAccessorAnnotations.ts, 22, 22)) +>value : Symbol(value, Decl(circularAccessorAnnotations.ts, 23, 12)) +>T3 : Symbol(T3, Decl(circularAccessorAnnotations.ts, 19, 1)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types new file mode 100644 index 0000000000000..2b01358a33dca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/circularAccessorAnnotations.ts] //// + +=== circularAccessorAnnotations.ts === +declare const c1: { +>c1 : { readonly foo: typeof c1.foo; } + + get foo(): typeof c1.foo; +>foo : any +>c1.foo : any +>c1 : { readonly foo: typeof c1.foo; } +>foo : any +} + +declare const c2: { +>c2 : { foo: typeof c2.foo; } + + set foo(value: typeof c2.foo); +>foo : any +>value : any +>c2.foo : any +>c2 : { foo: typeof c2.foo; } +>foo : any +} + +declare const c3: { +>c3 : { foo: string; } + + get foo(): string; +>foo : string + + set foo(value: typeof c3.foo); +>foo : string +>value : string +>c3.foo : string +>c3 : { foo: string; } +>foo : string +} + +type T1 = { +>T1 : T1 + + get foo(): T1["foo"]; +>foo : any +} + +type T2 = { +>T2 : T2 + + set foo(value: T2["foo"]); +>foo : any +>value : any +} + +type T3 = { +>T3 : T3 + + get foo(): string; +>foo : string + + set foo(value: T3["foo"]); +>foo : string +>value : string +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt new file mode 100644 index 0000000000000..8d26d18d8fb2f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt @@ -0,0 +1,17 @@ +circularIndexedPropertyInstantiation.ts(4,5): error TS2589: Type instantiation is excessively deep and possibly infinite. +circularIndexedPropertyInstantiation.ts(4,9): error TS2589: Type instantiation is excessively deep and possibly infinite. +circularIndexedPropertyInstantiation.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + + +==== circularIndexedPropertyInstantiation.ts (3 errors) ==== + // Repro from #14837 + + type Foo = { "true": Foo> }[T]; + let f1: Foo<"true", {}>; + ~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + let f2: Foo<"false", {}>; + ~~~~~~~ +!!! error TS2344: Type '"false"' does not satisfy the constraint '"true"'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.js b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.js new file mode 100644 index 0000000000000..ac6aa726ab7a4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.js @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/circularIndexedPropertyInstantiation.ts] //// + +//// [circularIndexedPropertyInstantiation.ts] +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +let f1: Foo<"true", {}>; +let f2: Foo<"false", {}>; + +//// [circularIndexedPropertyInstantiation.js] +"use strict"; +// Repro from #14837 +let f1; +let f2; diff --git a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.symbols b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.symbols new file mode 100644 index 0000000000000..5473bd4665786 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.symbols @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/circularIndexedPropertyInstantiation.ts] //// + +=== circularIndexedPropertyInstantiation.ts === +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +>Foo : Symbol(Foo, Decl(circularIndexedPropertyInstantiation.ts, 0, 0)) +>T : Symbol(T, Decl(circularIndexedPropertyInstantiation.ts, 2, 9)) +>B : Symbol(B, Decl(circularIndexedPropertyInstantiation.ts, 2, 26)) +>"true" : Symbol("true", Decl(circularIndexedPropertyInstantiation.ts, 2, 33)) +>Foo : Symbol(Foo, Decl(circularIndexedPropertyInstantiation.ts, 0, 0)) +>T : Symbol(T, Decl(circularIndexedPropertyInstantiation.ts, 2, 9)) +>Foo : Symbol(Foo, Decl(circularIndexedPropertyInstantiation.ts, 0, 0)) +>T : Symbol(T, Decl(circularIndexedPropertyInstantiation.ts, 2, 9)) +>B : Symbol(B, Decl(circularIndexedPropertyInstantiation.ts, 2, 26)) +>T : Symbol(T, Decl(circularIndexedPropertyInstantiation.ts, 2, 9)) + +let f1: Foo<"true", {}>; +>f1 : Symbol(f1, Decl(circularIndexedPropertyInstantiation.ts, 3, 3)) +>Foo : Symbol(Foo, Decl(circularIndexedPropertyInstantiation.ts, 0, 0)) + +let f2: Foo<"false", {}>; +>f2 : Symbol(f2, Decl(circularIndexedPropertyInstantiation.ts, 4, 3)) +>Foo : Symbol(Foo, Decl(circularIndexedPropertyInstantiation.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.types b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.types new file mode 100644 index 0000000000000..789407f9e698b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.types @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/circularIndexedPropertyInstantiation.ts] //// + +=== circularIndexedPropertyInstantiation.ts === +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +>Foo : Foo +>"true" : Foo> + +let f1: Foo<"true", {}>; +>f1 : any + +let f2: Foo<"false", {}>; +>f2 : unknown + diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).errors.txt b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).errors.txt new file mode 100644 index 0000000000000..0accf5ec5ec5d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).errors.txt @@ -0,0 +1,40 @@ +circularInitializerInference.ts(6,14): error TS2695: Left side of comma operator is unused and has no side effects. +circularInitializerInference.ts(9,20): error TS2695: Left side of comma operator is unused and has no side effects. +circularInitializerInference.ts(9,20): error TS2695: Left side of comma operator is unused and has no side effects. + + +==== circularInitializerInference.ts (3 errors) ==== + export {}; + + type IsAny = 0 extends (1 & Type) ? true : false; + type Assert = Condition; + + var comma = (comma, 3); + ~~~~~ +!!! error TS2695: Left side of comma operator is unused and has no side effects. + type CommaInference = Assert>; + + var nestedComma = (comma, nestedComma, comma); + ~~~~~ +!!! error TS2695: Left side of comma operator is unused and has no side effects. + ~~~~~~~~~~~~~~~~~~ +!!! error TS2695: Left side of comma operator is unused and has no side effects. + type NestedCommaInference = Assert>; + + var assignment = (assignment = 2); + type AssignmentInference = Assert>; + + var nestedAssignment = (nestedAssignment = nestedAssignment = 2); + type NestedAssignmentInference = Assert>; + + var conditional = conditional ? 0 : 1; + type ConditionalInference = Assert>; + + var logicalAnd = logicalAnd && ""; + type LogicalAndInference = Assert>; + + var propertyAccess = { member: propertyAccess.member }; + type PropertyAccessInference = Assert>; + + const nonCircular: number = 3; + type NonCircularInference = Assert extends false ? true : false>; \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).js b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).js new file mode 100644 index 0000000000000..6b1e6c702f422 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).js @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/circularInitializerInference.ts] //// + +//// [circularInitializerInference.ts] +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +type Assert = Condition; + +var comma = (comma, 3); +type CommaInference = Assert>; + +var nestedComma = (comma, nestedComma, comma); +type NestedCommaInference = Assert>; + +var assignment = (assignment = 2); +type AssignmentInference = Assert>; + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +type NestedAssignmentInference = Assert>; + +var conditional = conditional ? 0 : 1; +type ConditionalInference = Assert>; + +var logicalAnd = logicalAnd && ""; +type LogicalAndInference = Assert>; + +var propertyAccess = { member: propertyAccess.member }; +type PropertyAccessInference = Assert>; + +const nonCircular: number = 3; +type NonCircularInference = Assert extends false ? true : false>; + +//// [circularInitializerInference.js] +var comma = (comma, 3); +var nestedComma = (comma, nestedComma, comma); +var assignment = (assignment = 2); +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +var conditional = conditional ? 0 : 1; +var logicalAnd = logicalAnd && ""; +var propertyAccess = { member: propertyAccess.member }; +const nonCircular = 3; +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).symbols b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).symbols new file mode 100644 index 0000000000000..7146dd252c8ef --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).symbols @@ -0,0 +1,98 @@ +//// [tests/cases/compiler/circularInitializerInference.ts] //// + +=== circularInitializerInference.ts === +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>Type : Symbol(Type, Decl(circularInitializerInference.ts, 2, 11)) +>Type : Symbol(Type, Decl(circularInitializerInference.ts, 2, 11)) + +type Assert = Condition; +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>Condition : Symbol(Condition, Decl(circularInitializerInference.ts, 3, 12)) +>Condition : Symbol(Condition, Decl(circularInitializerInference.ts, 3, 12)) + +var comma = (comma, 3); +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) + +type CommaInference = Assert>; +>CommaInference : Symbol(CommaInference, Decl(circularInitializerInference.ts, 5, 23)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) + +var nestedComma = (comma, nestedComma, comma); +>nestedComma : Symbol(nestedComma, Decl(circularInitializerInference.ts, 8, 3)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) +>nestedComma : Symbol(nestedComma, Decl(circularInitializerInference.ts, 8, 3)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) + +type NestedCommaInference = Assert>; +>NestedCommaInference : Symbol(NestedCommaInference, Decl(circularInitializerInference.ts, 8, 46)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>nestedComma : Symbol(nestedComma, Decl(circularInitializerInference.ts, 8, 3)) + +var assignment = (assignment = 2); +>assignment : Symbol(assignment, Decl(circularInitializerInference.ts, 11, 3)) +>assignment : Symbol(assignment, Decl(circularInitializerInference.ts, 11, 3)) + +type AssignmentInference = Assert>; +>AssignmentInference : Symbol(AssignmentInference, Decl(circularInitializerInference.ts, 11, 34)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>assignment : Symbol(assignment, Decl(circularInitializerInference.ts, 11, 3)) + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) + +type NestedAssignmentInference = Assert>; +>NestedAssignmentInference : Symbol(NestedAssignmentInference, Decl(circularInitializerInference.ts, 14, 65)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) + +var conditional = conditional ? 0 : 1; +>conditional : Symbol(conditional, Decl(circularInitializerInference.ts, 17, 3)) +>conditional : Symbol(conditional, Decl(circularInitializerInference.ts, 17, 3)) + +type ConditionalInference = Assert>; +>ConditionalInference : Symbol(ConditionalInference, Decl(circularInitializerInference.ts, 17, 38)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>conditional : Symbol(conditional, Decl(circularInitializerInference.ts, 17, 3)) + +var logicalAnd = logicalAnd && ""; +>logicalAnd : Symbol(logicalAnd, Decl(circularInitializerInference.ts, 20, 3)) +>logicalAnd : Symbol(logicalAnd, Decl(circularInitializerInference.ts, 20, 3)) + +type LogicalAndInference = Assert>; +>LogicalAndInference : Symbol(LogicalAndInference, Decl(circularInitializerInference.ts, 20, 34)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>logicalAnd : Symbol(logicalAnd, Decl(circularInitializerInference.ts, 20, 3)) + +var propertyAccess = { member: propertyAccess.member }; +>propertyAccess : Symbol(propertyAccess, Decl(circularInitializerInference.ts, 23, 3)) +>member : Symbol(member, Decl(circularInitializerInference.ts, 23, 22)) +>propertyAccess : Symbol(propertyAccess, Decl(circularInitializerInference.ts, 23, 3)) + +type PropertyAccessInference = Assert>; +>PropertyAccessInference : Symbol(PropertyAccessInference, Decl(circularInitializerInference.ts, 23, 55)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>propertyAccess : Symbol(propertyAccess, Decl(circularInitializerInference.ts, 23, 3)) + +const nonCircular: number = 3; +>nonCircular : Symbol(nonCircular, Decl(circularInitializerInference.ts, 26, 5)) + +type NonCircularInference = Assert extends false ? true : false>; +>NonCircularInference : Symbol(NonCircularInference, Decl(circularInitializerInference.ts, 26, 30)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>nonCircular : Symbol(nonCircular, Decl(circularInitializerInference.ts, 26, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).types b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).types new file mode 100644 index 0000000000000..c9d5c077f18ad --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).types @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/circularInitializerInference.ts] //// + +=== circularInitializerInference.ts === +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +>IsAny : IsAny +>true : true +>false : false + +type Assert = Condition; +>Assert : Condition +>true : true + +var comma = (comma, 3); +>comma : any +>(comma, 3) : 3 +>comma, 3 : 3 +>comma : any +>3 : 3 + +type CommaInference = Assert>; +>CommaInference : true +>comma : any + +var nestedComma = (comma, nestedComma, comma); +>nestedComma : any +>(comma, nestedComma, comma) : any +>comma, nestedComma, comma : any +>comma, nestedComma : any +>comma : any +>nestedComma : any +>comma : any + +type NestedCommaInference = Assert>; +>NestedCommaInference : true +>nestedComma : any + +var assignment = (assignment = 2); +>assignment : any +>(assignment = 2) : 2 +>assignment = 2 : 2 +>assignment : any +>2 : 2 + +type AssignmentInference = Assert>; +>AssignmentInference : true +>assignment : any + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +>nestedAssignment : any +>(nestedAssignment = nestedAssignment = 2) : 2 +>nestedAssignment = nestedAssignment = 2 : 2 +>nestedAssignment : any +>nestedAssignment = 2 : 2 +>nestedAssignment : any +>2 : 2 + +type NestedAssignmentInference = Assert>; +>NestedAssignmentInference : true +>nestedAssignment : any + +var conditional = conditional ? 0 : 1; +>conditional : any +>conditional ? 0 : 1 : 0 | 1 +>conditional : any +>0 : 0 +>1 : 1 + +type ConditionalInference = Assert>; +>ConditionalInference : true +>conditional : any + +var logicalAnd = logicalAnd && ""; +>logicalAnd : any +>logicalAnd && "" : "" +>logicalAnd : any +>"" : "" + +type LogicalAndInference = Assert>; +>LogicalAndInference : true +>logicalAnd : any + +var propertyAccess = { member: propertyAccess.member }; +>propertyAccess : any +>{ member: propertyAccess.member } : { member: any; } +>member : any +>propertyAccess.member : any +>propertyAccess : any +>member : any + +type PropertyAccessInference = Assert>; +>PropertyAccessInference : true +>propertyAccess : any + +const nonCircular: number = 3; +>nonCircular : number +>3 : 3 + +type NonCircularInference = Assert extends false ? true : false>; +>NonCircularInference : true +>nonCircular : number +>false : false +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).errors.txt b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).errors.txt new file mode 100644 index 0000000000000..f7f94d4a4b3bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).errors.txt @@ -0,0 +1,61 @@ +circularInitializerInference.ts(6,5): error TS7022: 'comma' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularInitializerInference.ts(6,14): error TS2695: Left side of comma operator is unused and has no side effects. +circularInitializerInference.ts(9,5): error TS7022: 'nestedComma' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularInitializerInference.ts(9,20): error TS2695: Left side of comma operator is unused and has no side effects. +circularInitializerInference.ts(9,20): error TS2695: Left side of comma operator is unused and has no side effects. +circularInitializerInference.ts(12,5): error TS7022: 'assignment' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularInitializerInference.ts(15,5): error TS7022: 'nestedAssignment' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularInitializerInference.ts(18,5): error TS7022: 'conditional' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularInitializerInference.ts(21,5): error TS7022: 'logicalAnd' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularInitializerInference.ts(24,5): error TS7022: 'propertyAccess' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + + +==== circularInitializerInference.ts (10 errors) ==== + export {}; + + type IsAny = 0 extends (1 & Type) ? true : false; + type Assert = Condition; + + var comma = (comma, 3); + ~~~~~ +!!! error TS7022: 'comma' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~~~~~ +!!! error TS2695: Left side of comma operator is unused and has no side effects. + type CommaInference = Assert>; + + var nestedComma = (comma, nestedComma, comma); + ~~~~~~~~~~~ +!!! error TS7022: 'nestedComma' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~~~~~ +!!! error TS2695: Left side of comma operator is unused and has no side effects. + ~~~~~~~~~~~~~~~~~~ +!!! error TS2695: Left side of comma operator is unused and has no side effects. + type NestedCommaInference = Assert>; + + var assignment = (assignment = 2); + ~~~~~~~~~~ +!!! error TS7022: 'assignment' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + type AssignmentInference = Assert>; + + var nestedAssignment = (nestedAssignment = nestedAssignment = 2); + ~~~~~~~~~~~~~~~~ +!!! error TS7022: 'nestedAssignment' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + type NestedAssignmentInference = Assert>; + + var conditional = conditional ? 0 : 1; + ~~~~~~~~~~~ +!!! error TS7022: 'conditional' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + type ConditionalInference = Assert>; + + var logicalAnd = logicalAnd && ""; + ~~~~~~~~~~ +!!! error TS7022: 'logicalAnd' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + type LogicalAndInference = Assert>; + + var propertyAccess = { member: propertyAccess.member }; + ~~~~~~~~~~~~~~ +!!! error TS7022: 'propertyAccess' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + type PropertyAccessInference = Assert>; + + const nonCircular: number = 3; + type NonCircularInference = Assert extends false ? true : false>; \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).js b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).js new file mode 100644 index 0000000000000..6b1e6c702f422 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).js @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/circularInitializerInference.ts] //// + +//// [circularInitializerInference.ts] +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +type Assert = Condition; + +var comma = (comma, 3); +type CommaInference = Assert>; + +var nestedComma = (comma, nestedComma, comma); +type NestedCommaInference = Assert>; + +var assignment = (assignment = 2); +type AssignmentInference = Assert>; + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +type NestedAssignmentInference = Assert>; + +var conditional = conditional ? 0 : 1; +type ConditionalInference = Assert>; + +var logicalAnd = logicalAnd && ""; +type LogicalAndInference = Assert>; + +var propertyAccess = { member: propertyAccess.member }; +type PropertyAccessInference = Assert>; + +const nonCircular: number = 3; +type NonCircularInference = Assert extends false ? true : false>; + +//// [circularInitializerInference.js] +var comma = (comma, 3); +var nestedComma = (comma, nestedComma, comma); +var assignment = (assignment = 2); +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +var conditional = conditional ? 0 : 1; +var logicalAnd = logicalAnd && ""; +var propertyAccess = { member: propertyAccess.member }; +const nonCircular = 3; +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).symbols b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).symbols new file mode 100644 index 0000000000000..7146dd252c8ef --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).symbols @@ -0,0 +1,98 @@ +//// [tests/cases/compiler/circularInitializerInference.ts] //// + +=== circularInitializerInference.ts === +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>Type : Symbol(Type, Decl(circularInitializerInference.ts, 2, 11)) +>Type : Symbol(Type, Decl(circularInitializerInference.ts, 2, 11)) + +type Assert = Condition; +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>Condition : Symbol(Condition, Decl(circularInitializerInference.ts, 3, 12)) +>Condition : Symbol(Condition, Decl(circularInitializerInference.ts, 3, 12)) + +var comma = (comma, 3); +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) + +type CommaInference = Assert>; +>CommaInference : Symbol(CommaInference, Decl(circularInitializerInference.ts, 5, 23)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) + +var nestedComma = (comma, nestedComma, comma); +>nestedComma : Symbol(nestedComma, Decl(circularInitializerInference.ts, 8, 3)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) +>nestedComma : Symbol(nestedComma, Decl(circularInitializerInference.ts, 8, 3)) +>comma : Symbol(comma, Decl(circularInitializerInference.ts, 5, 3)) + +type NestedCommaInference = Assert>; +>NestedCommaInference : Symbol(NestedCommaInference, Decl(circularInitializerInference.ts, 8, 46)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>nestedComma : Symbol(nestedComma, Decl(circularInitializerInference.ts, 8, 3)) + +var assignment = (assignment = 2); +>assignment : Symbol(assignment, Decl(circularInitializerInference.ts, 11, 3)) +>assignment : Symbol(assignment, Decl(circularInitializerInference.ts, 11, 3)) + +type AssignmentInference = Assert>; +>AssignmentInference : Symbol(AssignmentInference, Decl(circularInitializerInference.ts, 11, 34)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>assignment : Symbol(assignment, Decl(circularInitializerInference.ts, 11, 3)) + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) + +type NestedAssignmentInference = Assert>; +>NestedAssignmentInference : Symbol(NestedAssignmentInference, Decl(circularInitializerInference.ts, 14, 65)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>nestedAssignment : Symbol(nestedAssignment, Decl(circularInitializerInference.ts, 14, 3)) + +var conditional = conditional ? 0 : 1; +>conditional : Symbol(conditional, Decl(circularInitializerInference.ts, 17, 3)) +>conditional : Symbol(conditional, Decl(circularInitializerInference.ts, 17, 3)) + +type ConditionalInference = Assert>; +>ConditionalInference : Symbol(ConditionalInference, Decl(circularInitializerInference.ts, 17, 38)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>conditional : Symbol(conditional, Decl(circularInitializerInference.ts, 17, 3)) + +var logicalAnd = logicalAnd && ""; +>logicalAnd : Symbol(logicalAnd, Decl(circularInitializerInference.ts, 20, 3)) +>logicalAnd : Symbol(logicalAnd, Decl(circularInitializerInference.ts, 20, 3)) + +type LogicalAndInference = Assert>; +>LogicalAndInference : Symbol(LogicalAndInference, Decl(circularInitializerInference.ts, 20, 34)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>logicalAnd : Symbol(logicalAnd, Decl(circularInitializerInference.ts, 20, 3)) + +var propertyAccess = { member: propertyAccess.member }; +>propertyAccess : Symbol(propertyAccess, Decl(circularInitializerInference.ts, 23, 3)) +>member : Symbol(member, Decl(circularInitializerInference.ts, 23, 22)) +>propertyAccess : Symbol(propertyAccess, Decl(circularInitializerInference.ts, 23, 3)) + +type PropertyAccessInference = Assert>; +>PropertyAccessInference : Symbol(PropertyAccessInference, Decl(circularInitializerInference.ts, 23, 55)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>propertyAccess : Symbol(propertyAccess, Decl(circularInitializerInference.ts, 23, 3)) + +const nonCircular: number = 3; +>nonCircular : Symbol(nonCircular, Decl(circularInitializerInference.ts, 26, 5)) + +type NonCircularInference = Assert extends false ? true : false>; +>NonCircularInference : Symbol(NonCircularInference, Decl(circularInitializerInference.ts, 26, 30)) +>Assert : Symbol(Assert, Decl(circularInitializerInference.ts, 2, 55)) +>IsAny : Symbol(IsAny, Decl(circularInitializerInference.ts, 0, 10)) +>nonCircular : Symbol(nonCircular, Decl(circularInitializerInference.ts, 26, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).types b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).types new file mode 100644 index 0000000000000..93d72c091cab5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).types @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/circularInitializerInference.ts] //// + +=== circularInitializerInference.ts === +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +>IsAny : IsAny +>true : true +>false : false + +type Assert = Condition; +>Assert : Condition +>true : true + +var comma = (comma, 3); +>comma : any +>(comma, 3) : 3 +>comma, 3 : 3 +>comma : any +>3 : 3 + +type CommaInference = Assert>; +>CommaInference : true +>comma : any + +var nestedComma = (comma, nestedComma, comma); +>nestedComma : any +>(comma, nestedComma, comma) : any +>comma, nestedComma, comma : any +>comma, nestedComma : any +>comma : any +>nestedComma : any +>comma : any + +type NestedCommaInference = Assert>; +>NestedCommaInference : true +>nestedComma : any + +var assignment = (assignment = 2); +>assignment : any +>(assignment = 2) : 2 +>assignment = 2 : 2 +>assignment : any +>2 : 2 + +type AssignmentInference = Assert>; +>AssignmentInference : true +>assignment : any + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +>nestedAssignment : any +>(nestedAssignment = nestedAssignment = 2) : 2 +>nestedAssignment = nestedAssignment = 2 : 2 +>nestedAssignment : any +>nestedAssignment = 2 : 2 +>nestedAssignment : any +>2 : 2 + +type NestedAssignmentInference = Assert>; +>NestedAssignmentInference : true +>nestedAssignment : any + +var conditional = conditional ? 0 : 1; +>conditional : any +>conditional ? 0 : 1 : 0 | 1 +>conditional : any +>0 : 0 +>1 : 1 + +type ConditionalInference = Assert>; +>ConditionalInference : true +>conditional : any + +var logicalAnd = logicalAnd && ""; +>logicalAnd : any +>logicalAnd && "" : any +>logicalAnd : any +>"" : "" + +type LogicalAndInference = Assert>; +>LogicalAndInference : true +>logicalAnd : any + +var propertyAccess = { member: propertyAccess.member }; +>propertyAccess : any +>{ member: propertyAccess.member } : { member: any; } +>member : any +>propertyAccess.member : any +>propertyAccess : any +>member : any + +type PropertyAccessInference = Assert>; +>PropertyAccessInference : true +>propertyAccess : any + +const nonCircular: number = 3; +>nonCircular : number +>3 : 3 + +type NonCircularInference = Assert extends false ? true : false>; +>NonCircularInference : true +>nonCircular : number +>false : false +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt new file mode 100644 index 0000000000000..61ac052a41c80 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt @@ -0,0 +1,23 @@ +circularInlineMappedGenericTupleTypeNoCrash.ts(11,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +circularInlineMappedGenericTupleTypeNoCrash.ts(11,60): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== circularInlineMappedGenericTupleTypeNoCrash.ts (2 errors) ==== + class Foo { + public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; + + public constructor( + ...elements: { [P in keyof Elements]: { bar: Elements[P] } } + ) { + this.elements = elements; + } + + public add(): Foo<[...Elements, "abc"]> { + return new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).symbols new file mode 100644 index 0000000000000..c5a706f25c93c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).symbols @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts] //// + +=== circularInlineMappedGenericTupleTypeNoCrash.ts === +class Foo { +>Foo : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) + + public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; +>elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 1, 31)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>bar : Symbol(bar, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 1, 54)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 1, 31)) + + public constructor( + ...elements: { [P in keyof Elements]: { bar: Elements[P] } } +>elements : Symbol(elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 3, 21)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 4, 20)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>bar : Symbol(bar, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 4, 43)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 4, 20)) + + ) { + this.elements = elements; +>this.elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>this : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>elements : Symbol(elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 3, 21)) + } + + public add(): Foo<[...Elements, "abc"]> { +>add : Symbol(Foo.add, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 7, 3)) +>Foo : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) + + return new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }); +>Foo : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>this.elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>this : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>bar : Symbol(bar, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 10, 60)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).types new file mode 100644 index 0000000000000..660b3ff1bac7e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts] //// + +=== circularInlineMappedGenericTupleTypeNoCrash.ts === +class Foo { +>Foo : Foo + + public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>bar : Elements[P] + + public constructor( + ...elements: { [P in keyof Elements]: { bar: Elements[P] } } +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>bar : Elements[P] + + ) { + this.elements = elements; +>this.elements = elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>this.elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>this : this +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } + } + + public add(): Foo<[...Elements, "abc"]> { +>add : () => Foo<[...Elements, "abc"]> + + return new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }); +>new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }) : Foo<[...Elements, "abc"]> +>Foo : typeof Foo +>...this.elements : { bar: unknown; } +>this.elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>this : this +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>{ bar: "abc" } : { bar: string; } +>bar : string +>"abc" : "abc" + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..61ac052a41c80 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt @@ -0,0 +1,23 @@ +circularInlineMappedGenericTupleTypeNoCrash.ts(11,12): error TS2589: Type instantiation is excessively deep and possibly infinite. +circularInlineMappedGenericTupleTypeNoCrash.ts(11,60): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== circularInlineMappedGenericTupleTypeNoCrash.ts (2 errors) ==== + class Foo { + public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; + + public constructor( + ...elements: { [P in keyof Elements]: { bar: Elements[P] } } + ) { + this.elements = elements; + } + + public add(): Foo<[...Elements, "abc"]> { + return new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c5a706f25c93c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).symbols @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts] //// + +=== circularInlineMappedGenericTupleTypeNoCrash.ts === +class Foo { +>Foo : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) + + public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; +>elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 1, 31)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>bar : Symbol(bar, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 1, 54)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 1, 31)) + + public constructor( + ...elements: { [P in keyof Elements]: { bar: Elements[P] } } +>elements : Symbol(elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 3, 21)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 4, 20)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>bar : Symbol(bar, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 4, 43)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>P : Symbol(P, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 4, 20)) + + ) { + this.elements = elements; +>this.elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>this : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>elements : Symbol(elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 3, 21)) + } + + public add(): Foo<[...Elements, "abc"]> { +>add : Symbol(Foo.add, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 7, 3)) +>Foo : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) + + return new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }); +>Foo : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>Elements : Symbol(Elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 10)) +>this.elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>this : Symbol(Foo, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 0)) +>elements : Symbol(Foo.elements, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 0, 48)) +>bar : Symbol(bar, Decl(circularInlineMappedGenericTupleTypeNoCrash.ts, 10, 60)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).types new file mode 100644 index 0000000000000..660b3ff1bac7e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts] //// + +=== circularInlineMappedGenericTupleTypeNoCrash.ts === +class Foo { +>Foo : Foo + + public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>bar : Elements[P] + + public constructor( + ...elements: { [P in keyof Elements]: { bar: Elements[P] } } +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>bar : Elements[P] + + ) { + this.elements = elements; +>this.elements = elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>this.elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>this : this +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } + } + + public add(): Foo<[...Elements, "abc"]> { +>add : () => Foo<[...Elements, "abc"]> + + return new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }); +>new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }) : Foo<[...Elements, "abc"]> +>Foo : typeof Foo +>...this.elements : { bar: unknown; } +>this.elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>this : this +>elements : { [P in keyof Elements]: { bar: Elements[P]; }; } +>{ bar: "abc" } : { bar: string; } +>bar : string +>"abc" : "abc" + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt new file mode 100644 index 0000000000000..5f36a6dd6ba9d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt @@ -0,0 +1,62 @@ +declaration.ts(6,5): error TS7023: 'rebuild' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +declaration.ts(9,5): error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +expression.ts(10,7): error TS2322: Type 'typeof A' is not assignable to type 'new () => A'. + Type 'A' is not assignable to type 'A'. Two different types with this name exist, but they are unrelated. + Types of property 'c' are incompatible. + Type '() => () => any' is not assignable to type 'A'. +expression.ts(11,5): error TS7023: 'rebuild' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +expression.ts(14,5): error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== expression.ts (3 errors) ==== + // Subtype reduction of rebuild's return type relates the class to A, + // which needs b's return type, which needs rebuild's: a cycle. Both + // members report it, whichever return type is requested first, as if + // rebuild's, declared first, were requested first. + interface A { + b(): A; + c: A; + } + declare const flag: boolean; + const A: new () => A = class { + ~ +!!! error TS2322: Type 'typeof A' is not assignable to type 'new () => A'. +!!! error TS2322: Type 'A' is not assignable to type 'A'. Two different types with this name exist, but they are unrelated. +!!! error TS2322: Types of property 'c' are incompatible. +!!! error TS2322: Type '() => () => any' is not assignable to type 'A'. + rebuild() { + ~~~~~~~ +!!! error TS7023: 'rebuild' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return flag ? this : new A(); + } + b() { + ~ +!!! error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return this.rebuild(); + } + c() { + return this.rebuild; + } + }; + export {}; + +==== declaration.ts (2 errors) ==== + interface B { + b(): B; + } + declare const flag: boolean; + class K { + rebuild() { + ~~~~~~~ +!!! error TS7023: 'rebuild' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return flag ? this : new B(); + } + b() { + ~ +!!! error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return this.rebuild(); + } + } + const B: new () => B = K; + export {}; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.symbols new file mode 100644 index 0000000000000..5706cdcb8e401 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.symbols @@ -0,0 +1,90 @@ +//// [tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts] //// + +=== expression.ts === +// Subtype reduction of rebuild's return type relates the class to A, +// which needs b's return type, which needs rebuild's: a cycle. Both +// members report it, whichever return type is requested first, as if +// rebuild's, declared first, were requested first. +interface A { +>A : Symbol(A, Decl(expression.ts, 0, 0), Decl(expression.ts, 9, 5)) + + b(): A; +>b : Symbol(A.b, Decl(expression.ts, 4, 13)) +>A : Symbol(A, Decl(expression.ts, 0, 0), Decl(expression.ts, 9, 5)) + + c: A; +>c : Symbol(A.c, Decl(expression.ts, 5, 11)) +>A : Symbol(A, Decl(expression.ts, 0, 0), Decl(expression.ts, 9, 5)) +} +declare const flag: boolean; +>flag : Symbol(flag, Decl(expression.ts, 8, 13)) + +const A: new () => A = class { +>A : Symbol(A, Decl(expression.ts, 0, 0), Decl(expression.ts, 9, 5)) +>A : Symbol(A, Decl(expression.ts, 0, 0), Decl(expression.ts, 9, 5)) + + rebuild() { +>rebuild : Symbol(A.rebuild, Decl(expression.ts, 9, 30)) + + return flag ? this : new A(); +>flag : Symbol(flag, Decl(expression.ts, 8, 13)) +>this : Symbol(A, Decl(expression.ts, 9, 22)) +>A : Symbol(A, Decl(expression.ts, 0, 0), Decl(expression.ts, 9, 5)) + } + b() { +>b : Symbol(A.b, Decl(expression.ts, 12, 5)) + + return this.rebuild(); +>this.rebuild : Symbol(A.rebuild, Decl(expression.ts, 9, 30)) +>this : Symbol(A, Decl(expression.ts, 9, 22)) +>rebuild : Symbol(A.rebuild, Decl(expression.ts, 9, 30)) + } + c() { +>c : Symbol(A.c, Decl(expression.ts, 15, 5)) + + return this.rebuild; +>this.rebuild : Symbol(A.rebuild, Decl(expression.ts, 9, 30)) +>this : Symbol(A, Decl(expression.ts, 9, 22)) +>rebuild : Symbol(A.rebuild, Decl(expression.ts, 9, 30)) + } +}; +export {}; + +=== declaration.ts === +interface B { +>B : Symbol(B, Decl(declaration.ts, 0, 0), Decl(declaration.ts, 12, 5)) + + b(): B; +>b : Symbol(B.b, Decl(declaration.ts, 0, 13)) +>B : Symbol(B, Decl(declaration.ts, 0, 0), Decl(declaration.ts, 12, 5)) +} +declare const flag: boolean; +>flag : Symbol(flag, Decl(declaration.ts, 3, 13)) + +class K { +>K : Symbol(K, Decl(declaration.ts, 3, 28)) + + rebuild() { +>rebuild : Symbol(K.rebuild, Decl(declaration.ts, 4, 9)) + + return flag ? this : new B(); +>flag : Symbol(flag, Decl(declaration.ts, 3, 13)) +>this : Symbol(K, Decl(declaration.ts, 3, 28)) +>B : Symbol(B, Decl(declaration.ts, 0, 0), Decl(declaration.ts, 12, 5)) + } + b() { +>b : Symbol(K.b, Decl(declaration.ts, 7, 5)) + + return this.rebuild(); +>this.rebuild : Symbol(K.rebuild, Decl(declaration.ts, 4, 9)) +>this : Symbol(K, Decl(declaration.ts, 3, 28)) +>rebuild : Symbol(K.rebuild, Decl(declaration.ts, 4, 9)) + } +} +const B: new () => B = K; +>B : Symbol(B, Decl(declaration.ts, 0, 0), Decl(declaration.ts, 12, 5)) +>B : Symbol(B, Decl(declaration.ts, 0, 0), Decl(declaration.ts, 12, 5)) +>K : Symbol(K, Decl(declaration.ts, 3, 28)) + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types new file mode 100644 index 0000000000000..421302078810c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types @@ -0,0 +1,88 @@ +//// [tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts] //// + +=== expression.ts === +// Subtype reduction of rebuild's return type relates the class to A, +// which needs b's return type, which needs rebuild's: a cycle. Both +// members report it, whichever return type is requested first, as if +// rebuild's, declared first, were requested first. +interface A { + b(): A; +>b : () => A + + c: A; +>c : A +} +declare const flag: boolean; +>flag : boolean + +const A: new () => A = class { +>A : new () => A +>class { rebuild() { return flag ? this : new A(); } b() { return this.rebuild(); } c() { return this.rebuild; }} : typeof A + + rebuild() { +>rebuild : () => any + + return flag ? this : new A(); +>flag ? this : new A() : this | A +>flag : boolean +>this : this +>new A() : A +>A : new () => A + } + b() { +>b : () => any + + return this.rebuild(); +>this.rebuild() : any +>this.rebuild : () => any +>this : this +>rebuild : () => any + } + c() { +>c : () => () => any + + return this.rebuild; +>this.rebuild : () => any +>this : this +>rebuild : () => any + } +}; +export {}; + +=== declaration.ts === +interface B { + b(): B; +>b : () => B +} +declare const flag: boolean; +>flag : boolean + +class K { +>K : K + + rebuild() { +>rebuild : () => any + + return flag ? this : new B(); +>flag ? this : new B() : this | B +>flag : boolean +>this : this +>new B() : B +>B : new () => B + } + b() { +>b : () => any + + return this.rebuild(); +>this.rebuild() : any +>this.rebuild : () => any +>this : this +>rebuild : () => any + } +} +const B: new () => B = K; +>B : new () => B +>K : typeof K + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).symbols new file mode 100644 index 0000000000000..c320ee58e23b7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>m : Symbol(Base.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 16)) + +declare function config(config: { f?: () => Base }): void; +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 24)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 33)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) + +declare const h: Heading; +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const b: Base = h; +>b : Symbol(b, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 5)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) + +class Heading { +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + + m() { +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + + return config({ f: () => create() }); +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 17, 23)) +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) + } +} + +declare function create(): Heading; +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const r: void = new Heading().m(); +>r : Symbol(r, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 5)) +>new Heading().m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>input : Symbol(input, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 15)) + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 20)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) +>_tag : Symbol(UndefinedNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 25)) +>getParser : Symbol(UndefinedNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 53)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +type AST = NullNode | UndefinedNode; +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>ast : Symbol(ast, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 27)) +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>value : Symbol(value, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 36)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +const NullNode: new () => NullNode = class { +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) + + readonly _tag = "Null"; +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 44)) + + getParser() { +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 33, 27)) + + return fromConst(this, null); +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>this : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 36)) + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Symbol(p, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 39, 5)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>new NullNode().getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).types new file mode 100644 index 0000000000000..21a3ba0434560 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).types @@ -0,0 +1,102 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>m : () => unknown + +declare function config(config: { f?: () => Base }): void; +>config : (config: { f?: () => Base; }) => void +>config : { f?: () => Base; } +>f : (() => Base) | undefined + +declare const h: Heading; +>h : Heading + +const b: Base = h; +>b : Base +>h : Heading + +class Heading { +>Heading : Heading + + m() { +>m : () => void + + return config({ f: () => create() }); +>config({ f: () => create() }) : void +>config : (config: { f?: () => Base; }) => void +>{ f: () => create() } : { f: () => Heading; } +>f : () => Heading +>() => create() : () => Heading +>create() : Heading +>create : () => Heading + } +} + +declare function create(): Heading; +>create : () => Heading + +const r: void = new Heading().m(); +>r : void +>new Heading().m() : void +>new Heading().m : () => void +>new Heading() : Heading +>Heading : typeof Heading +>m : () => void + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Parser +>input : unknown + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>_tag : "Null" +>getParser : () => Parser + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>_tag : "Undefined" +>getParser : () => Parser + +type AST = NullNode | UndefinedNode; +>AST : AST + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : (ast: AST, value: unknown) => Parser +>ast : AST +>value : unknown + +const NullNode: new () => NullNode = class { +>NullNode : new () => NullNode +>class { readonly _tag = "Null"; getParser() { return fromConst(this, null); }} : typeof NullNode + + readonly _tag = "Null"; +>_tag : "Null" +>"Null" : "Null" + + getParser() { +>getParser : () => Parser + + return fromConst(this, null); +>fromConst(this, null) : Parser +>fromConst : (ast: AST, value: unknown) => Parser +>this : this + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Parser +>new NullNode().getParser() : Parser +>new NullNode().getParser : () => Parser +>new NullNode() : NullNode +>NullNode : new () => NullNode +>getParser : () => Parser + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c320ee58e23b7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>m : Symbol(Base.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 16)) + +declare function config(config: { f?: () => Base }): void; +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 24)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 33)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) + +declare const h: Heading; +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const b: Base = h; +>b : Symbol(b, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 5)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) + +class Heading { +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + + m() { +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + + return config({ f: () => create() }); +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 17, 23)) +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) + } +} + +declare function create(): Heading; +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const r: void = new Heading().m(); +>r : Symbol(r, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 5)) +>new Heading().m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>input : Symbol(input, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 15)) + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 20)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) +>_tag : Symbol(UndefinedNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 25)) +>getParser : Symbol(UndefinedNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 53)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +type AST = NullNode | UndefinedNode; +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>ast : Symbol(ast, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 27)) +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>value : Symbol(value, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 36)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +const NullNode: new () => NullNode = class { +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) + + readonly _tag = "Null"; +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 44)) + + getParser() { +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 33, 27)) + + return fromConst(this, null); +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>this : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 36)) + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Symbol(p, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 39, 5)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>new NullNode().getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).types new file mode 100644 index 0000000000000..21a3ba0434560 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).types @@ -0,0 +1,102 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>m : () => unknown + +declare function config(config: { f?: () => Base }): void; +>config : (config: { f?: () => Base; }) => void +>config : { f?: () => Base; } +>f : (() => Base) | undefined + +declare const h: Heading; +>h : Heading + +const b: Base = h; +>b : Base +>h : Heading + +class Heading { +>Heading : Heading + + m() { +>m : () => void + + return config({ f: () => create() }); +>config({ f: () => create() }) : void +>config : (config: { f?: () => Base; }) => void +>{ f: () => create() } : { f: () => Heading; } +>f : () => Heading +>() => create() : () => Heading +>create() : Heading +>create : () => Heading + } +} + +declare function create(): Heading; +>create : () => Heading + +const r: void = new Heading().m(); +>r : void +>new Heading().m() : void +>new Heading().m : () => void +>new Heading() : Heading +>Heading : typeof Heading +>m : () => void + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Parser +>input : unknown + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>_tag : "Null" +>getParser : () => Parser + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>_tag : "Undefined" +>getParser : () => Parser + +type AST = NullNode | UndefinedNode; +>AST : AST + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : (ast: AST, value: unknown) => Parser +>ast : AST +>value : unknown + +const NullNode: new () => NullNode = class { +>NullNode : new () => NullNode +>class { readonly _tag = "Null"; getParser() { return fromConst(this, null); }} : typeof NullNode + + readonly _tag = "Null"; +>_tag : "Null" +>"Null" : "Null" + + getParser() { +>getParser : () => Parser + + return fromConst(this, null); +>fromConst(this, null) : Parser +>fromConst : (ast: AST, value: unknown) => Parser +>this : this + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Parser +>new NullNode().getParser() : Parser +>new NullNode().getParser : () => Parser +>new NullNode() : NullNode +>NullNode : new () => NullNode +>getParser : () => Parser + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).symbols new file mode 100644 index 0000000000000..6db3b443be191 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).symbols @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 21)) + +export function a(n: number) { +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) + + return fan(() => a(n)); +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 42)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 69)) + +export async function b(n: number) { +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + if (n > 0) { +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + return fanAll(() => b(n - 1)); +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + } + return { ok: true }; +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 12, 12)) +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>success : Symbol(success, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 15)) +>key : Symbol(key, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 35)) + +interface Other { success: boolean; url: string } +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) +>success : Symbol(Other.success, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 17)) +>url : Symbol(Other.url, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 35)) + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>generateOne : Symbol(generateOne, Decl(circularReturnTypeThroughCallbackArgument.ts, 17, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) + +declare const other: Other; +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) + +export async function c(n: number) { +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) + + if (n) return other; +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) + + return fanOut(() => c(n - 1)); +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types new file mode 100644 index 0000000000000..fb9e85bf2b1d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types @@ -0,0 +1,86 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : (g: () => number) => number +>g : () => number + +export function a(n: number) { +>a : (n: number) => any +>n : number + + return fan(() => a(n)); +>fan(() => a(n)) : number +>fan : (g: () => number) => number +>() => a(n) : () => any +>a(n) : any +>a : (n: number) => any +>n : number +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>g : () => Promise<{ ok: boolean; }> +>ok : boolean +>ok : boolean + +export async function b(n: number) { +>b : (n: number) => any +>n : number + + if (n > 0) { +>n > 0 : boolean +>n : number +>0 : 0 + + return fanAll(() => b(n - 1)); +>fanAll(() => b(n - 1)) : Promise<{ ok: boolean; }> +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>() => b(n - 1) : () => any +>b(n - 1) : any +>b : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 + } + return { ok: true }; +>{ ok: true } : { ok: boolean; } +>ok : boolean +>true : true +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Result +>success : boolean +>key : string + +interface Other { success: boolean; url: string } +>success : boolean +>url : string + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : (generateOne: () => Promise) => Promise +>generateOne : () => Promise + +declare const other: Other; +>other : Other + +export async function c(n: number) { +>c : (n: number) => any +>n : number + + if (n) return other; +>n : number +>other : Other + + return fanOut(() => c(n - 1)); +>fanOut(() => c(n - 1)) : Promise +>fanOut : (generateOne: () => Promise) => Promise +>() => c(n - 1) : () => any +>c(n - 1) : any +>c : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt new file mode 100644 index 0000000000000..a10fc6bcbe59c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt @@ -0,0 +1,46 @@ +circularReturnTypeThroughCallbackArgument.ts(3,17): error TS7023: 'a' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(4,16): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(9,23): error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(11,23): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(21,23): error TS7023: 'c' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(23,19): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== circularReturnTypeThroughCallbackArgument.ts (6 errors) ==== + declare function fan(g: () => number): number; + + export function a(n: number) { + ~ +!!! error TS7023: 'a' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return fan(() => a(n)); + ~~~~~~~~~~ +!!! error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + } + + declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; + + export async function b(n: number) { + ~ +!!! error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + if (n > 0) { + return fanAll(() => b(n - 1)); + ~~~~~~~~~~~~~~ +!!! error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + } + return { ok: true }; + } + + type Result = { success: boolean; [key: string]: unknown }; + interface Other { success: boolean; url: string } + declare function fanOut(generateOne: () => Promise): Promise; + declare const other: Other; + + export async function c(n: number) { + ~ +!!! error TS7023: 'c' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + if (n) return other; + return fanOut(() => c(n - 1)); + ~~~~~~~~~~~~~~ +!!! error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).symbols new file mode 100644 index 0000000000000..6db3b443be191 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).symbols @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 21)) + +export function a(n: number) { +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) + + return fan(() => a(n)); +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 42)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 69)) + +export async function b(n: number) { +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + if (n > 0) { +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + return fanAll(() => b(n - 1)); +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + } + return { ok: true }; +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 12, 12)) +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>success : Symbol(success, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 15)) +>key : Symbol(key, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 35)) + +interface Other { success: boolean; url: string } +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) +>success : Symbol(Other.success, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 17)) +>url : Symbol(Other.url, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 35)) + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>generateOne : Symbol(generateOne, Decl(circularReturnTypeThroughCallbackArgument.ts, 17, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) + +declare const other: Other; +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) + +export async function c(n: number) { +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) + + if (n) return other; +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) + + return fanOut(() => c(n - 1)); +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types new file mode 100644 index 0000000000000..fb9e85bf2b1d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types @@ -0,0 +1,86 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : (g: () => number) => number +>g : () => number + +export function a(n: number) { +>a : (n: number) => any +>n : number + + return fan(() => a(n)); +>fan(() => a(n)) : number +>fan : (g: () => number) => number +>() => a(n) : () => any +>a(n) : any +>a : (n: number) => any +>n : number +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>g : () => Promise<{ ok: boolean; }> +>ok : boolean +>ok : boolean + +export async function b(n: number) { +>b : (n: number) => any +>n : number + + if (n > 0) { +>n > 0 : boolean +>n : number +>0 : 0 + + return fanAll(() => b(n - 1)); +>fanAll(() => b(n - 1)) : Promise<{ ok: boolean; }> +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>() => b(n - 1) : () => any +>b(n - 1) : any +>b : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 + } + return { ok: true }; +>{ ok: true } : { ok: boolean; } +>ok : boolean +>true : true +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Result +>success : boolean +>key : string + +interface Other { success: boolean; url: string } +>success : boolean +>url : string + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : (generateOne: () => Promise) => Promise +>generateOne : () => Promise + +declare const other: Other; +>other : Other + +export async function c(n: number) { +>c : (n: number) => any +>n : number + + if (n) return other; +>n : number +>other : Other + + return fanOut(() => c(n - 1)); +>fanOut(() => c(n - 1)) : Promise +>fanOut : (generateOne: () => Promise) => Promise +>() => c(n - 1) : () => any +>c(n - 1) : any +>c : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).symbols new file mode 100644 index 0000000000000..f53077d24860e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : Symbol(x, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>extra : Symbol(extra, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 29)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 37)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 46)) + +function getCreds() { +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + const next = (id: string) => getCreds(); +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 9)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 18)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + return materialize({ next }); +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 14, 24)) +} + +const n: number = getCreds(); +>n : Symbol(n, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 17, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).types new file mode 100644 index 0000000000000..5cf5a07fe7c0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : number +>getCreds() : number +>getCreds : () => number + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>extra : { next?: (id: string) => unknown; } +>next : ((id: string) => unknown) | undefined +>id : string + +function getCreds() { +>getCreds : () => number + + const next = (id: string) => getCreds(); +>next : (id: string) => number +>(id: string) => getCreds() : (id: string) => number +>id : string +>getCreds() : number +>getCreds : () => number + + return materialize({ next }); +>materialize({ next }) : number +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>{ next } : { next: (id: string) => number; } +>next : (id: string) => number +} + +const n: number = getCreds(); +>n : number +>getCreds() : number +>getCreds : () => number + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..f53077d24860e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : Symbol(x, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>extra : Symbol(extra, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 29)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 37)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 46)) + +function getCreds() { +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + const next = (id: string) => getCreds(); +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 9)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 18)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + return materialize({ next }); +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 14, 24)) +} + +const n: number = getCreds(); +>n : Symbol(n, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 17, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).types new file mode 100644 index 0000000000000..5cf5a07fe7c0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : number +>getCreds() : number +>getCreds : () => number + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>extra : { next?: (id: string) => unknown; } +>next : ((id: string) => unknown) | undefined +>id : string + +function getCreds() { +>getCreds : () => number + + const next = (id: string) => getCreds(); +>next : (id: string) => number +>(id: string) => getCreds() : (id: string) => number +>id : string +>getCreds() : number +>getCreds : () => number + + return materialize({ next }); +>materialize({ next }) : number +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>{ next } : { next: (id: string) => number; } +>next : (id: string) => number +} + +const n: number = getCreds(); +>n : number +>getCreds() : number +>getCreds : () => number + diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols new file mode 100644 index 0000000000000..cefed83354abf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols @@ -0,0 +1,121 @@ +//// [tests/cases/compiler/circularScopeThunkReverseMapped.ts] //// + +=== circularScopeThunkReverseMapped.ts === +type Resolve = T extends () => infer R ? R : T; +>Resolve : Symbol(Resolve, Decl(circularScopeThunkReverseMapped.ts, 0, 0)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 0, 39)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 0, 39)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) + +type Validate = { [K in keyof def]: def[K] extends () => infer R ? () => R : def[K] }; +>Validate : Symbol(Validate, Decl(circularScopeThunkReverseMapped.ts, 0, 50)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 1, 67)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 1, 67)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) + +interface Scope { +>Scope : Symbol(Scope, Decl(circularScopeThunkReverseMapped.ts, 1, 91)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) + + type(k: k): Resolve; +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>Resolve : Symbol(Resolve, Decl(circularScopeThunkReverseMapped.ts, 0, 0)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +} +interface Type { +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 5, 15)) + + pipe(f: (x: T) => U): Type; +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +>f : Symbol(f, Decl(circularScopeThunkReverseMapped.ts, 6, 12)) +>x : Symbol(x, Decl(circularScopeThunkReverseMapped.ts, 6, 16)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 5, 15)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +} +declare function scope(def: Validate): Scope; +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>Validate : Symbol(Validate, Decl(circularScopeThunkReverseMapped.ts, 0, 50)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>Scope : Symbol(Scope, Decl(circularScopeThunkReverseMapped.ts, 1, 91)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) + +declare function type(x: T): Type; +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) +>x : Symbol(x, Decl(circularScopeThunkReverseMapped.ts, 9, 25)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) + +export const $ = scope({ +>$ : Symbol($, Decl(circularScopeThunkReverseMapped.ts, 11, 12)) +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) + + a: type("string").pipe(function (s) { return s.length; }), +>a : Symbol(a, Decl(circularScopeThunkReverseMapped.ts, 11, 24)) +>type("string").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 12, 37)) +>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 12, 37)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + b: () => $.type("a").pipe(function (n) { return n === 0; }), +>b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 12, 62)) +>$.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>$.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>$ : Symbol($, Decl(circularScopeThunkReverseMapped.ts, 11, 12)) +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40)) + +}); + +// Entered from the function in the first property when queried in reverse +export const $2 = scope({ +>$2 : Symbol($2, Decl(circularScopeThunkReverseMapped.ts, 17, 12)) +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) + + a: type("string").pipe(function (s) { return s.length; }), +>a : Symbol(a, Decl(circularScopeThunkReverseMapped.ts, 17, 25)) +>type("string").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 18, 37)) +>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 18, 37)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + b: () => $2.type("a").pipe((n: number) => n === 0), +>b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 18, 62)) +>$2.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>$2.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>$2 : Symbol($2, Decl(circularScopeThunkReverseMapped.ts, 17, 12)) +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types new file mode 100644 index 0000000000000..6edac2ffefa43 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types @@ -0,0 +1,107 @@ +//// [tests/cases/compiler/circularScopeThunkReverseMapped.ts] //// + +=== circularScopeThunkReverseMapped.ts === +type Resolve = T extends () => infer R ? R : T; +>Resolve : Resolve + +type Validate = { [K in keyof def]: def[K] extends () => infer R ? () => R : def[K] }; +>Validate : Validate + +interface Scope { + type(k: k): Resolve; +>type : (k: k) => Resolve +>k : k +} +interface Type { + pipe(f: (x: T) => U): Type; +>pipe : (f: (x: T) => U) => Type +>f : (x: T) => U +>x : T +} +declare function scope(def: Validate): Scope; +>scope : (def: Validate) => Scope +>def : Validate + +declare function type(x: T): Type; +>type : (x: T) => Type +>x : T + +export const $ = scope({ +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope : (def: Validate) => Scope +>{ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => Type; } + + a: type("string").pipe(function (s) { return s.length; }), +>a : Type +>type("string").pipe(function (s) { return s.length; }) : Type +>type("string").pipe : (f: (x: string) => U) => Type +>type("string") : Type +>type : (x: T) => Type +>"string" : "string" +>pipe : (f: (x: string) => U) => Type +>function (s) { return s.length; } : (s: string) => number +>s : string +>s.length : number +>s : string +>length : number + + b: () => $.type("a").pipe(function (n) { return n === 0; }), +>b : () => Type +>() => $.type("a").pipe(function (n) { return n === 0; }) : () => Type +>$.type("a").pipe(function (n) { return n === 0; }) : Type +>$.type("a").pipe : (f: (x: number) => U) => Type +>$.type("a") : Type +>$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>"a" : "a" +>pipe : (f: (x: number) => U) => Type +>function (n) { return n === 0; } : (n: number) => n is 0 +>n : number +>n === 0 : boolean +>n : number +>0 : 0 + +}); + +// Entered from the function in the first property when queried in reverse +export const $2 = scope({ +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope : (def: Validate) => Scope +>{ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => Type; } + + a: type("string").pipe(function (s) { return s.length; }), +>a : Type +>type("string").pipe(function (s) { return s.length; }) : Type +>type("string").pipe : (f: (x: string) => U) => Type +>type("string") : Type +>type : (x: T) => Type +>"string" : "string" +>pipe : (f: (x: string) => U) => Type +>function (s) { return s.length; } : (s: string) => number +>s : string +>s.length : number +>s : string +>length : number + + b: () => $2.type("a").pipe((n: number) => n === 0), +>b : () => Type +>() => $2.type("a").pipe((n: number) => n === 0) : () => Type +>$2.type("a").pipe((n: number) => n === 0) : Type +>$2.type("a").pipe : (f: (x: number) => U) => Type +>$2.type("a") : Type +>$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>"a" : "a" +>pipe : (f: (x: number) => U) => Type +>(n: number) => n === 0 : (n: number) => n is 0 +>n : number +>n === 0 : boolean +>n : number +>0 : 0 + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..cefed83354abf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols @@ -0,0 +1,121 @@ +//// [tests/cases/compiler/circularScopeThunkReverseMapped.ts] //// + +=== circularScopeThunkReverseMapped.ts === +type Resolve = T extends () => infer R ? R : T; +>Resolve : Symbol(Resolve, Decl(circularScopeThunkReverseMapped.ts, 0, 0)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 0, 39)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 0, 39)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) + +type Validate = { [K in keyof def]: def[K] extends () => infer R ? () => R : def[K] }; +>Validate : Symbol(Validate, Decl(circularScopeThunkReverseMapped.ts, 0, 50)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 1, 67)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 1, 67)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) + +interface Scope { +>Scope : Symbol(Scope, Decl(circularScopeThunkReverseMapped.ts, 1, 91)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) + + type(k: k): Resolve; +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>Resolve : Symbol(Resolve, Decl(circularScopeThunkReverseMapped.ts, 0, 0)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +} +interface Type { +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 5, 15)) + + pipe(f: (x: T) => U): Type; +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +>f : Symbol(f, Decl(circularScopeThunkReverseMapped.ts, 6, 12)) +>x : Symbol(x, Decl(circularScopeThunkReverseMapped.ts, 6, 16)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 5, 15)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +} +declare function scope(def: Validate): Scope; +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>Validate : Symbol(Validate, Decl(circularScopeThunkReverseMapped.ts, 0, 50)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>Scope : Symbol(Scope, Decl(circularScopeThunkReverseMapped.ts, 1, 91)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) + +declare function type(x: T): Type; +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) +>x : Symbol(x, Decl(circularScopeThunkReverseMapped.ts, 9, 25)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) + +export const $ = scope({ +>$ : Symbol($, Decl(circularScopeThunkReverseMapped.ts, 11, 12)) +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) + + a: type("string").pipe(function (s) { return s.length; }), +>a : Symbol(a, Decl(circularScopeThunkReverseMapped.ts, 11, 24)) +>type("string").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 12, 37)) +>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 12, 37)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + b: () => $.type("a").pipe(function (n) { return n === 0; }), +>b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 12, 62)) +>$.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>$.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>$ : Symbol($, Decl(circularScopeThunkReverseMapped.ts, 11, 12)) +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40)) + +}); + +// Entered from the function in the first property when queried in reverse +export const $2 = scope({ +>$2 : Symbol($2, Decl(circularScopeThunkReverseMapped.ts, 17, 12)) +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) + + a: type("string").pipe(function (s) { return s.length; }), +>a : Symbol(a, Decl(circularScopeThunkReverseMapped.ts, 17, 25)) +>type("string").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 18, 37)) +>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 18, 37)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + b: () => $2.type("a").pipe((n: number) => n === 0), +>b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 18, 62)) +>$2.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>$2.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>$2 : Symbol($2, Decl(circularScopeThunkReverseMapped.ts, 17, 12)) +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types new file mode 100644 index 0000000000000..6edac2ffefa43 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types @@ -0,0 +1,107 @@ +//// [tests/cases/compiler/circularScopeThunkReverseMapped.ts] //// + +=== circularScopeThunkReverseMapped.ts === +type Resolve = T extends () => infer R ? R : T; +>Resolve : Resolve + +type Validate = { [K in keyof def]: def[K] extends () => infer R ? () => R : def[K] }; +>Validate : Validate + +interface Scope { + type(k: k): Resolve; +>type : (k: k) => Resolve +>k : k +} +interface Type { + pipe(f: (x: T) => U): Type; +>pipe : (f: (x: T) => U) => Type +>f : (x: T) => U +>x : T +} +declare function scope(def: Validate): Scope; +>scope : (def: Validate) => Scope +>def : Validate + +declare function type(x: T): Type; +>type : (x: T) => Type +>x : T + +export const $ = scope({ +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope : (def: Validate) => Scope +>{ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => Type; } + + a: type("string").pipe(function (s) { return s.length; }), +>a : Type +>type("string").pipe(function (s) { return s.length; }) : Type +>type("string").pipe : (f: (x: string) => U) => Type +>type("string") : Type +>type : (x: T) => Type +>"string" : "string" +>pipe : (f: (x: string) => U) => Type +>function (s) { return s.length; } : (s: string) => number +>s : string +>s.length : number +>s : string +>length : number + + b: () => $.type("a").pipe(function (n) { return n === 0; }), +>b : () => Type +>() => $.type("a").pipe(function (n) { return n === 0; }) : () => Type +>$.type("a").pipe(function (n) { return n === 0; }) : Type +>$.type("a").pipe : (f: (x: number) => U) => Type +>$.type("a") : Type +>$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>"a" : "a" +>pipe : (f: (x: number) => U) => Type +>function (n) { return n === 0; } : (n: number) => n is 0 +>n : number +>n === 0 : boolean +>n : number +>0 : 0 + +}); + +// Entered from the function in the first property when queried in reverse +export const $2 = scope({ +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope : (def: Validate) => Scope +>{ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => Type; } + + a: type("string").pipe(function (s) { return s.length; }), +>a : Type +>type("string").pipe(function (s) { return s.length; }) : Type +>type("string").pipe : (f: (x: string) => U) => Type +>type("string") : Type +>type : (x: T) => Type +>"string" : "string" +>pipe : (f: (x: string) => U) => Type +>function (s) { return s.length; } : (s: string) => number +>s : string +>s.length : number +>s : string +>length : number + + b: () => $2.type("a").pipe((n: number) => n === 0), +>b : () => Type +>() => $2.type("a").pipe((n: number) => n === 0) : () => Type +>$2.type("a").pipe((n: number) => n === 0) : Type +>$2.type("a").pipe : (f: (x: number) => U) => Type +>$2.type("a") : Type +>$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>"a" : "a" +>pipe : (f: (x: number) => U) => Type +>(n: number) => n === 0 : (n: number) => n is 0 +>n : number +>n === 0 : boolean +>n : number +>0 : 0 + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).errors.txt b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).errors.txt new file mode 100644 index 0000000000000..e6a85a2793754 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).errors.txt @@ -0,0 +1,80 @@ +classCircularityDiagnostics.ts(1,7): error TS2506: 'Direct' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(9,7): error TS2506: 'First' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(9,21): error TS2449: Class 'Second' used before its declaration. +classCircularityDiagnostics.ts(10,7): error TS2506: 'Second' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(12,26): error TS2506: 'Named' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(23,16): error TS2448: Block-scoped variable 'SelfReferencingBase' used before its declaration. +classCircularityDiagnostics.ts(41,44): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. +classCircularityDiagnostics.ts(42,58): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. +classCircularityDiagnostics.ts(45,34): error TS2507: Type 'number' is not a constructor function type. +classCircularityDiagnostics.ts(45,50): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== classCircularityDiagnostics.ts (10 errors) ==== + class Direct extends Direct { + ~~~~~~ +!!! error TS2506: 'Direct' is referenced directly or indirectly in its own base expression. + static value = 1; + value = 2; + } + + const staticValue = Direct.value; + const instanceValue = new Direct().value; + + class First extends Second {} + ~~~~~ +!!! error TS2506: 'First' is referenced directly or indirectly in its own base expression. + ~~~~~~ +!!! error TS2449: Class 'Second' used before its declaration. +!!! related TS2728 classCircularityDiagnostics.ts:10:7: 'Second' is declared here. + class Second extends First {} + ~~~~~~ +!!! error TS2506: 'Second' is referenced directly or indirectly in its own base expression. + + const Expression = class Named extends Named {}; + ~~~~~ +!!! error TS2506: 'Named' is referenced directly or indirectly in its own base expression. + + class NestedBase extends (class { + static value = 1; + value = 2; + }) {} + + const nestedStaticValue: number = NestedBase.value; + const nestedInstanceValue: number = new NestedBase().value; + + const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2448: Block-scoped variable 'SelfReferencingBase' used before its declaration. +!!! related TS2728 classCircularityDiagnostics.ts:22:7: 'SelfReferencingBase' is declared here. + }) {}; + + const selfConstructor = SelfReferencingBase.self; + + function mixin {}>(base: Base) { + return class extends base { + static value = 1; + value = 2; + }; + } + + class Mixed extends mixin(NestedBase) {} + + const mixedStaticValue: number = Mixed.value; + const mixedInstanceValue: number = new Mixed().value; + + declare function makeBase(value: number): typeof NestedBase; + class InvalidBaseArgument extends makeBase("invalid") {} + ~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + const InvalidExpressionArgument = class extends makeBase("invalid") {}; + ~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + declare function makeInvalidBase(value: number): number; + class InvalidConstructor extends makeInvalidBase("invalid") {} + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2507: Type 'number' is not a constructor function type. + ~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).js b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).js new file mode 100644 index 0000000000000..2ff93ac2eb65b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).js @@ -0,0 +1,91 @@ +//// [tests/cases/compiler/classCircularityDiagnostics.ts] //// + +//// [classCircularityDiagnostics.ts] +class Direct extends Direct { + static value = 1; + value = 2; +} + +const staticValue = Direct.value; +const instanceValue = new Direct().value; + +class First extends Second {} +class Second extends First {} + +const Expression = class Named extends Named {}; + +class NestedBase extends (class { + static value = 1; + value = 2; +}) {} + +const nestedStaticValue: number = NestedBase.value; +const nestedInstanceValue: number = new NestedBase().value; + +const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; +}) {}; + +const selfConstructor = SelfReferencingBase.self; + +function mixin {}>(base: Base) { + return class extends base { + static value = 1; + value = 2; + }; +} + +class Mixed extends mixin(NestedBase) {} + +const mixedStaticValue: number = Mixed.value; +const mixedInstanceValue: number = new Mixed().value; + +declare function makeBase(value: number): typeof NestedBase; +class InvalidBaseArgument extends makeBase("invalid") {} +const InvalidExpressionArgument = class extends makeBase("invalid") {}; + +declare function makeInvalidBase(value: number): number; +class InvalidConstructor extends makeInvalidBase("invalid") {} + +//// [classCircularityDiagnostics.js] +"use strict"; +class Direct extends Direct { + static value = 1; + value = 2; +} +const staticValue = Direct.value; +const instanceValue = new Direct().value; +class First extends Second { +} +class Second extends First { +} +const Expression = class Named extends Named { +}; +class NestedBase extends (class { + static value = 1; + value = 2; +}) { +} +const nestedStaticValue = NestedBase.value; +const nestedInstanceValue = new NestedBase().value; +const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; +}) { +}; +const selfConstructor = SelfReferencingBase.self; +function mixin(base) { + return class extends base { + static value = 1; + value = 2; + }; +} +class Mixed extends mixin(NestedBase) { +} +const mixedStaticValue = Mixed.value; +const mixedInstanceValue = new Mixed().value; +class InvalidBaseArgument extends makeBase("invalid") { +} +const InvalidExpressionArgument = class extends makeBase("invalid") { +}; +class InvalidConstructor extends makeInvalidBase("invalid") { +} diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).symbols b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).symbols new file mode 100644 index 0000000000000..9e892a1edd0ab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).symbols @@ -0,0 +1,134 @@ +//// [tests/cases/compiler/classCircularityDiagnostics.ts] //// + +=== classCircularityDiagnostics.ts === +class Direct extends Direct { +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) + + static value = 1; +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 0, 29)) + + value = 2; +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 1, 18)) +} + +const staticValue = Direct.value; +>staticValue : Symbol(staticValue, Decl(classCircularityDiagnostics.ts, 5, 5)) +>Direct.value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 0, 29)) +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 0, 29)) + +const instanceValue = new Direct().value; +>instanceValue : Symbol(instanceValue, Decl(classCircularityDiagnostics.ts, 6, 5)) +>new Direct().value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 1, 18)) +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 1, 18)) + +class First extends Second {} +>First : Symbol(First, Decl(classCircularityDiagnostics.ts, 6, 41)) +>Second : Symbol(Second, Decl(classCircularityDiagnostics.ts, 8, 29)) + +class Second extends First {} +>Second : Symbol(Second, Decl(classCircularityDiagnostics.ts, 8, 29)) +>First : Symbol(First, Decl(classCircularityDiagnostics.ts, 6, 41)) + +const Expression = class Named extends Named {}; +>Expression : Symbol(Expression, Decl(classCircularityDiagnostics.ts, 11, 5)) +>Named : Symbol(Named, Decl(classCircularityDiagnostics.ts, 11, 18)) +>Named : Symbol(Named, Decl(classCircularityDiagnostics.ts, 11, 18)) + +class NestedBase extends (class { +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) + + static value = 1; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 13, 33)) + + value = 2; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 14, 18)) + +}) {} + +const nestedStaticValue: number = NestedBase.value; +>nestedStaticValue : Symbol(nestedStaticValue, Decl(classCircularityDiagnostics.ts, 18, 5)) +>NestedBase.value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 13, 33)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 13, 33)) + +const nestedInstanceValue: number = new NestedBase().value; +>nestedInstanceValue : Symbol(nestedInstanceValue, Decl(classCircularityDiagnostics.ts, 19, 5)) +>new NestedBase().value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 14, 18)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 14, 18)) + +const SelfReferencingBase = class extends (class { +>SelfReferencingBase : Symbol(SelfReferencingBase, Decl(classCircularityDiagnostics.ts, 21, 5)) + + static self = SelfReferencingBase; +>self : Symbol((Anonymous class).self, Decl(classCircularityDiagnostics.ts, 21, 50)) +>SelfReferencingBase : Symbol(SelfReferencingBase, Decl(classCircularityDiagnostics.ts, 21, 5)) + +}) {}; + +const selfConstructor = SelfReferencingBase.self; +>selfConstructor : Symbol(selfConstructor, Decl(classCircularityDiagnostics.ts, 25, 5)) +>SelfReferencingBase.self : Symbol((Anonymous class).self, Decl(classCircularityDiagnostics.ts, 21, 50)) +>SelfReferencingBase : Symbol(SelfReferencingBase, Decl(classCircularityDiagnostics.ts, 21, 5)) +>self : Symbol((Anonymous class).self, Decl(classCircularityDiagnostics.ts, 21, 50)) + +function mixin {}>(base: Base) { +>mixin : Symbol(mixin, Decl(classCircularityDiagnostics.ts, 25, 49)) +>Base : Symbol(Base, Decl(classCircularityDiagnostics.ts, 27, 15)) +>args : Symbol(args, Decl(classCircularityDiagnostics.ts, 27, 33)) +>base : Symbol(base, Decl(classCircularityDiagnostics.ts, 27, 56)) +>Base : Symbol(Base, Decl(classCircularityDiagnostics.ts, 27, 15)) + + return class extends base { +>base : Symbol(base, Decl(classCircularityDiagnostics.ts, 27, 56)) + + static value = 1; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 28, 28)) + + value = 2; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 29, 19)) + + }; +} + +class Mixed extends mixin(NestedBase) {} +>Mixed : Symbol(Mixed, Decl(classCircularityDiagnostics.ts, 32, 1)) +>mixin : Symbol(mixin, Decl(classCircularityDiagnostics.ts, 25, 49)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) + +const mixedStaticValue: number = Mixed.value; +>mixedStaticValue : Symbol(mixedStaticValue, Decl(classCircularityDiagnostics.ts, 36, 5)) +>Mixed.value : Symbol(value, Decl(classCircularityDiagnostics.ts, 28, 28), Decl(classCircularityDiagnostics.ts, 13, 33)) +>Mixed : Symbol(Mixed, Decl(classCircularityDiagnostics.ts, 32, 1)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 28, 28), Decl(classCircularityDiagnostics.ts, 13, 33)) + +const mixedInstanceValue: number = new Mixed().value; +>mixedInstanceValue : Symbol(mixedInstanceValue, Decl(classCircularityDiagnostics.ts, 37, 5)) +>new Mixed().value : Symbol(value, Decl(classCircularityDiagnostics.ts, 29, 19), Decl(classCircularityDiagnostics.ts, 14, 18)) +>Mixed : Symbol(Mixed, Decl(classCircularityDiagnostics.ts, 32, 1)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 29, 19), Decl(classCircularityDiagnostics.ts, 14, 18)) + +declare function makeBase(value: number): typeof NestedBase; +>makeBase : Symbol(makeBase, Decl(classCircularityDiagnostics.ts, 37, 53)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 39, 26)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) + +class InvalidBaseArgument extends makeBase("invalid") {} +>InvalidBaseArgument : Symbol(InvalidBaseArgument, Decl(classCircularityDiagnostics.ts, 39, 60)) +>makeBase : Symbol(makeBase, Decl(classCircularityDiagnostics.ts, 37, 53)) + +const InvalidExpressionArgument = class extends makeBase("invalid") {}; +>InvalidExpressionArgument : Symbol(InvalidExpressionArgument, Decl(classCircularityDiagnostics.ts, 41, 5)) +>makeBase : Symbol(makeBase, Decl(classCircularityDiagnostics.ts, 37, 53)) + +declare function makeInvalidBase(value: number): number; +>makeInvalidBase : Symbol(makeInvalidBase, Decl(classCircularityDiagnostics.ts, 41, 71)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 43, 33)) + +class InvalidConstructor extends makeInvalidBase("invalid") {} +>InvalidConstructor : Symbol(InvalidConstructor, Decl(classCircularityDiagnostics.ts, 43, 56)) +>makeInvalidBase : Symbol(makeInvalidBase, Decl(classCircularityDiagnostics.ts, 41, 71)) + diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).types b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).types new file mode 100644 index 0000000000000..0b46eec400402 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).types @@ -0,0 +1,156 @@ +//// [tests/cases/compiler/classCircularityDiagnostics.ts] //// + +=== classCircularityDiagnostics.ts === +class Direct extends Direct { +>Direct : Direct +>Direct : typeof Direct + + static value = 1; +>value : number +>1 : 1 + + value = 2; +>value : number +>2 : 2 +} + +const staticValue = Direct.value; +>staticValue : number +>Direct.value : number +>Direct : typeof Direct +>value : number + +const instanceValue = new Direct().value; +>instanceValue : number +>new Direct().value : number +>new Direct() : Direct +>Direct : typeof Direct +>value : number + +class First extends Second {} +>First : First +>Second : typeof Second + +class Second extends First {} +>Second : Second +>First : typeof First + +const Expression = class Named extends Named {}; +>Expression : typeof Named +>class Named extends Named {} : typeof Named +>Named : typeof Named +>Named : typeof Named + +class NestedBase extends (class { +>NestedBase : NestedBase +>(class { static value = 1; value = 2;}) : (Anonymous class) +>class { static value = 1; value = 2;} : typeof (Anonymous class) + + static value = 1; +>value : number +>1 : 1 + + value = 2; +>value : number +>2 : 2 + +}) {} + +const nestedStaticValue: number = NestedBase.value; +>nestedStaticValue : number +>NestedBase.value : number +>NestedBase : typeof NestedBase +>value : number + +const nestedInstanceValue: number = new NestedBase().value; +>nestedInstanceValue : number +>new NestedBase().value : number +>new NestedBase() : NestedBase +>NestedBase : typeof NestedBase +>value : number + +const SelfReferencingBase = class extends (class { +>SelfReferencingBase : typeof SelfReferencingBase +>class extends (class { static self = SelfReferencingBase;}) {} : typeof SelfReferencingBase +>(class { static self = SelfReferencingBase;}) : (Anonymous class) +>class { static self = SelfReferencingBase;} : typeof (Anonymous class) + + static self = SelfReferencingBase; +>self : typeof SelfReferencingBase +>SelfReferencingBase : typeof SelfReferencingBase + +}) {}; + +const selfConstructor = SelfReferencingBase.self; +>selfConstructor : typeof SelfReferencingBase +>SelfReferencingBase.self : typeof SelfReferencingBase +>SelfReferencingBase : typeof SelfReferencingBase +>self : typeof SelfReferencingBase + +function mixin {}>(base: Base) { +>mixin : {}>(base: Base) => { new (...args: any[]): (Anonymous class); value: number; prototype: mixin.(Anonymous class); } & Base +>args : any[] +>base : Base + + return class extends base { +>class extends base { static value = 1; value = 2; } : { new (...args: any[]): (Anonymous class); value: number; prototype: mixin.(Anonymous class); } & Base +>base : {} + + static value = 1; +>value : number +>1 : 1 + + value = 2; +>value : number +>2 : 2 + + }; +} + +class Mixed extends mixin(NestedBase) {} +>Mixed : Mixed +>mixin(NestedBase) : mixin.(Anonymous class) & NestedBase +>mixin : {}>(base: Base) => { new (...args: any[]): (Anonymous class); value: number; prototype: mixin.(Anonymous class); } & Base +>NestedBase : typeof NestedBase + +const mixedStaticValue: number = Mixed.value; +>mixedStaticValue : number +>Mixed.value : number +>Mixed : typeof Mixed +>value : number + +const mixedInstanceValue: number = new Mixed().value; +>mixedInstanceValue : number +>new Mixed().value : number +>new Mixed() : Mixed +>Mixed : typeof Mixed +>value : number + +declare function makeBase(value: number): typeof NestedBase; +>makeBase : (value: number) => typeof NestedBase +>value : number +>NestedBase : typeof NestedBase + +class InvalidBaseArgument extends makeBase("invalid") {} +>InvalidBaseArgument : InvalidBaseArgument +>makeBase("invalid") : NestedBase +>makeBase : (value: number) => typeof NestedBase +>"invalid" : "invalid" + +const InvalidExpressionArgument = class extends makeBase("invalid") {}; +>InvalidExpressionArgument : typeof InvalidExpressionArgument +>class extends makeBase("invalid") {} : typeof InvalidExpressionArgument +>makeBase("invalid") : NestedBase +>makeBase : (value: number) => typeof NestedBase +>"invalid" : "invalid" + +declare function makeInvalidBase(value: number): number; +>makeInvalidBase : (value: number) => number +>value : number + +class InvalidConstructor extends makeInvalidBase("invalid") {} +>InvalidConstructor : InvalidConstructor +>makeInvalidBase("invalid") : number +>makeInvalidBase : (value: number) => number +>"invalid" : "invalid" + diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).errors.txt b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).errors.txt new file mode 100644 index 0000000000000..e6a85a2793754 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).errors.txt @@ -0,0 +1,80 @@ +classCircularityDiagnostics.ts(1,7): error TS2506: 'Direct' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(9,7): error TS2506: 'First' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(9,21): error TS2449: Class 'Second' used before its declaration. +classCircularityDiagnostics.ts(10,7): error TS2506: 'Second' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(12,26): error TS2506: 'Named' is referenced directly or indirectly in its own base expression. +classCircularityDiagnostics.ts(23,16): error TS2448: Block-scoped variable 'SelfReferencingBase' used before its declaration. +classCircularityDiagnostics.ts(41,44): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. +classCircularityDiagnostics.ts(42,58): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. +classCircularityDiagnostics.ts(45,34): error TS2507: Type 'number' is not a constructor function type. +classCircularityDiagnostics.ts(45,50): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== classCircularityDiagnostics.ts (10 errors) ==== + class Direct extends Direct { + ~~~~~~ +!!! error TS2506: 'Direct' is referenced directly or indirectly in its own base expression. + static value = 1; + value = 2; + } + + const staticValue = Direct.value; + const instanceValue = new Direct().value; + + class First extends Second {} + ~~~~~ +!!! error TS2506: 'First' is referenced directly or indirectly in its own base expression. + ~~~~~~ +!!! error TS2449: Class 'Second' used before its declaration. +!!! related TS2728 classCircularityDiagnostics.ts:10:7: 'Second' is declared here. + class Second extends First {} + ~~~~~~ +!!! error TS2506: 'Second' is referenced directly or indirectly in its own base expression. + + const Expression = class Named extends Named {}; + ~~~~~ +!!! error TS2506: 'Named' is referenced directly or indirectly in its own base expression. + + class NestedBase extends (class { + static value = 1; + value = 2; + }) {} + + const nestedStaticValue: number = NestedBase.value; + const nestedInstanceValue: number = new NestedBase().value; + + const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2448: Block-scoped variable 'SelfReferencingBase' used before its declaration. +!!! related TS2728 classCircularityDiagnostics.ts:22:7: 'SelfReferencingBase' is declared here. + }) {}; + + const selfConstructor = SelfReferencingBase.self; + + function mixin {}>(base: Base) { + return class extends base { + static value = 1; + value = 2; + }; + } + + class Mixed extends mixin(NestedBase) {} + + const mixedStaticValue: number = Mixed.value; + const mixedInstanceValue: number = new Mixed().value; + + declare function makeBase(value: number): typeof NestedBase; + class InvalidBaseArgument extends makeBase("invalid") {} + ~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + const InvalidExpressionArgument = class extends makeBase("invalid") {}; + ~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + declare function makeInvalidBase(value: number): number; + class InvalidConstructor extends makeInvalidBase("invalid") {} + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2507: Type 'number' is not a constructor function type. + ~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).js b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).js new file mode 100644 index 0000000000000..2ff93ac2eb65b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).js @@ -0,0 +1,91 @@ +//// [tests/cases/compiler/classCircularityDiagnostics.ts] //// + +//// [classCircularityDiagnostics.ts] +class Direct extends Direct { + static value = 1; + value = 2; +} + +const staticValue = Direct.value; +const instanceValue = new Direct().value; + +class First extends Second {} +class Second extends First {} + +const Expression = class Named extends Named {}; + +class NestedBase extends (class { + static value = 1; + value = 2; +}) {} + +const nestedStaticValue: number = NestedBase.value; +const nestedInstanceValue: number = new NestedBase().value; + +const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; +}) {}; + +const selfConstructor = SelfReferencingBase.self; + +function mixin {}>(base: Base) { + return class extends base { + static value = 1; + value = 2; + }; +} + +class Mixed extends mixin(NestedBase) {} + +const mixedStaticValue: number = Mixed.value; +const mixedInstanceValue: number = new Mixed().value; + +declare function makeBase(value: number): typeof NestedBase; +class InvalidBaseArgument extends makeBase("invalid") {} +const InvalidExpressionArgument = class extends makeBase("invalid") {}; + +declare function makeInvalidBase(value: number): number; +class InvalidConstructor extends makeInvalidBase("invalid") {} + +//// [classCircularityDiagnostics.js] +"use strict"; +class Direct extends Direct { + static value = 1; + value = 2; +} +const staticValue = Direct.value; +const instanceValue = new Direct().value; +class First extends Second { +} +class Second extends First { +} +const Expression = class Named extends Named { +}; +class NestedBase extends (class { + static value = 1; + value = 2; +}) { +} +const nestedStaticValue = NestedBase.value; +const nestedInstanceValue = new NestedBase().value; +const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; +}) { +}; +const selfConstructor = SelfReferencingBase.self; +function mixin(base) { + return class extends base { + static value = 1; + value = 2; + }; +} +class Mixed extends mixin(NestedBase) { +} +const mixedStaticValue = Mixed.value; +const mixedInstanceValue = new Mixed().value; +class InvalidBaseArgument extends makeBase("invalid") { +} +const InvalidExpressionArgument = class extends makeBase("invalid") { +}; +class InvalidConstructor extends makeInvalidBase("invalid") { +} diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).symbols b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).symbols new file mode 100644 index 0000000000000..9e892a1edd0ab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).symbols @@ -0,0 +1,134 @@ +//// [tests/cases/compiler/classCircularityDiagnostics.ts] //// + +=== classCircularityDiagnostics.ts === +class Direct extends Direct { +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) + + static value = 1; +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 0, 29)) + + value = 2; +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 1, 18)) +} + +const staticValue = Direct.value; +>staticValue : Symbol(staticValue, Decl(classCircularityDiagnostics.ts, 5, 5)) +>Direct.value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 0, 29)) +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 0, 29)) + +const instanceValue = new Direct().value; +>instanceValue : Symbol(instanceValue, Decl(classCircularityDiagnostics.ts, 6, 5)) +>new Direct().value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 1, 18)) +>Direct : Symbol(Direct, Decl(classCircularityDiagnostics.ts, 0, 0)) +>value : Symbol(Direct.value, Decl(classCircularityDiagnostics.ts, 1, 18)) + +class First extends Second {} +>First : Symbol(First, Decl(classCircularityDiagnostics.ts, 6, 41)) +>Second : Symbol(Second, Decl(classCircularityDiagnostics.ts, 8, 29)) + +class Second extends First {} +>Second : Symbol(Second, Decl(classCircularityDiagnostics.ts, 8, 29)) +>First : Symbol(First, Decl(classCircularityDiagnostics.ts, 6, 41)) + +const Expression = class Named extends Named {}; +>Expression : Symbol(Expression, Decl(classCircularityDiagnostics.ts, 11, 5)) +>Named : Symbol(Named, Decl(classCircularityDiagnostics.ts, 11, 18)) +>Named : Symbol(Named, Decl(classCircularityDiagnostics.ts, 11, 18)) + +class NestedBase extends (class { +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) + + static value = 1; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 13, 33)) + + value = 2; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 14, 18)) + +}) {} + +const nestedStaticValue: number = NestedBase.value; +>nestedStaticValue : Symbol(nestedStaticValue, Decl(classCircularityDiagnostics.ts, 18, 5)) +>NestedBase.value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 13, 33)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 13, 33)) + +const nestedInstanceValue: number = new NestedBase().value; +>nestedInstanceValue : Symbol(nestedInstanceValue, Decl(classCircularityDiagnostics.ts, 19, 5)) +>new NestedBase().value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 14, 18)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 14, 18)) + +const SelfReferencingBase = class extends (class { +>SelfReferencingBase : Symbol(SelfReferencingBase, Decl(classCircularityDiagnostics.ts, 21, 5)) + + static self = SelfReferencingBase; +>self : Symbol((Anonymous class).self, Decl(classCircularityDiagnostics.ts, 21, 50)) +>SelfReferencingBase : Symbol(SelfReferencingBase, Decl(classCircularityDiagnostics.ts, 21, 5)) + +}) {}; + +const selfConstructor = SelfReferencingBase.self; +>selfConstructor : Symbol(selfConstructor, Decl(classCircularityDiagnostics.ts, 25, 5)) +>SelfReferencingBase.self : Symbol((Anonymous class).self, Decl(classCircularityDiagnostics.ts, 21, 50)) +>SelfReferencingBase : Symbol(SelfReferencingBase, Decl(classCircularityDiagnostics.ts, 21, 5)) +>self : Symbol((Anonymous class).self, Decl(classCircularityDiagnostics.ts, 21, 50)) + +function mixin {}>(base: Base) { +>mixin : Symbol(mixin, Decl(classCircularityDiagnostics.ts, 25, 49)) +>Base : Symbol(Base, Decl(classCircularityDiagnostics.ts, 27, 15)) +>args : Symbol(args, Decl(classCircularityDiagnostics.ts, 27, 33)) +>base : Symbol(base, Decl(classCircularityDiagnostics.ts, 27, 56)) +>Base : Symbol(Base, Decl(classCircularityDiagnostics.ts, 27, 15)) + + return class extends base { +>base : Symbol(base, Decl(classCircularityDiagnostics.ts, 27, 56)) + + static value = 1; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 28, 28)) + + value = 2; +>value : Symbol((Anonymous class).value, Decl(classCircularityDiagnostics.ts, 29, 19)) + + }; +} + +class Mixed extends mixin(NestedBase) {} +>Mixed : Symbol(Mixed, Decl(classCircularityDiagnostics.ts, 32, 1)) +>mixin : Symbol(mixin, Decl(classCircularityDiagnostics.ts, 25, 49)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) + +const mixedStaticValue: number = Mixed.value; +>mixedStaticValue : Symbol(mixedStaticValue, Decl(classCircularityDiagnostics.ts, 36, 5)) +>Mixed.value : Symbol(value, Decl(classCircularityDiagnostics.ts, 28, 28), Decl(classCircularityDiagnostics.ts, 13, 33)) +>Mixed : Symbol(Mixed, Decl(classCircularityDiagnostics.ts, 32, 1)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 28, 28), Decl(classCircularityDiagnostics.ts, 13, 33)) + +const mixedInstanceValue: number = new Mixed().value; +>mixedInstanceValue : Symbol(mixedInstanceValue, Decl(classCircularityDiagnostics.ts, 37, 5)) +>new Mixed().value : Symbol(value, Decl(classCircularityDiagnostics.ts, 29, 19), Decl(classCircularityDiagnostics.ts, 14, 18)) +>Mixed : Symbol(Mixed, Decl(classCircularityDiagnostics.ts, 32, 1)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 29, 19), Decl(classCircularityDiagnostics.ts, 14, 18)) + +declare function makeBase(value: number): typeof NestedBase; +>makeBase : Symbol(makeBase, Decl(classCircularityDiagnostics.ts, 37, 53)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 39, 26)) +>NestedBase : Symbol(NestedBase, Decl(classCircularityDiagnostics.ts, 11, 48)) + +class InvalidBaseArgument extends makeBase("invalid") {} +>InvalidBaseArgument : Symbol(InvalidBaseArgument, Decl(classCircularityDiagnostics.ts, 39, 60)) +>makeBase : Symbol(makeBase, Decl(classCircularityDiagnostics.ts, 37, 53)) + +const InvalidExpressionArgument = class extends makeBase("invalid") {}; +>InvalidExpressionArgument : Symbol(InvalidExpressionArgument, Decl(classCircularityDiagnostics.ts, 41, 5)) +>makeBase : Symbol(makeBase, Decl(classCircularityDiagnostics.ts, 37, 53)) + +declare function makeInvalidBase(value: number): number; +>makeInvalidBase : Symbol(makeInvalidBase, Decl(classCircularityDiagnostics.ts, 41, 71)) +>value : Symbol(value, Decl(classCircularityDiagnostics.ts, 43, 33)) + +class InvalidConstructor extends makeInvalidBase("invalid") {} +>InvalidConstructor : Symbol(InvalidConstructor, Decl(classCircularityDiagnostics.ts, 43, 56)) +>makeInvalidBase : Symbol(makeInvalidBase, Decl(classCircularityDiagnostics.ts, 41, 71)) + diff --git a/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).types b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).types new file mode 100644 index 0000000000000..0b46eec400402 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).types @@ -0,0 +1,156 @@ +//// [tests/cases/compiler/classCircularityDiagnostics.ts] //// + +=== classCircularityDiagnostics.ts === +class Direct extends Direct { +>Direct : Direct +>Direct : typeof Direct + + static value = 1; +>value : number +>1 : 1 + + value = 2; +>value : number +>2 : 2 +} + +const staticValue = Direct.value; +>staticValue : number +>Direct.value : number +>Direct : typeof Direct +>value : number + +const instanceValue = new Direct().value; +>instanceValue : number +>new Direct().value : number +>new Direct() : Direct +>Direct : typeof Direct +>value : number + +class First extends Second {} +>First : First +>Second : typeof Second + +class Second extends First {} +>Second : Second +>First : typeof First + +const Expression = class Named extends Named {}; +>Expression : typeof Named +>class Named extends Named {} : typeof Named +>Named : typeof Named +>Named : typeof Named + +class NestedBase extends (class { +>NestedBase : NestedBase +>(class { static value = 1; value = 2;}) : (Anonymous class) +>class { static value = 1; value = 2;} : typeof (Anonymous class) + + static value = 1; +>value : number +>1 : 1 + + value = 2; +>value : number +>2 : 2 + +}) {} + +const nestedStaticValue: number = NestedBase.value; +>nestedStaticValue : number +>NestedBase.value : number +>NestedBase : typeof NestedBase +>value : number + +const nestedInstanceValue: number = new NestedBase().value; +>nestedInstanceValue : number +>new NestedBase().value : number +>new NestedBase() : NestedBase +>NestedBase : typeof NestedBase +>value : number + +const SelfReferencingBase = class extends (class { +>SelfReferencingBase : typeof SelfReferencingBase +>class extends (class { static self = SelfReferencingBase;}) {} : typeof SelfReferencingBase +>(class { static self = SelfReferencingBase;}) : (Anonymous class) +>class { static self = SelfReferencingBase;} : typeof (Anonymous class) + + static self = SelfReferencingBase; +>self : typeof SelfReferencingBase +>SelfReferencingBase : typeof SelfReferencingBase + +}) {}; + +const selfConstructor = SelfReferencingBase.self; +>selfConstructor : typeof SelfReferencingBase +>SelfReferencingBase.self : typeof SelfReferencingBase +>SelfReferencingBase : typeof SelfReferencingBase +>self : typeof SelfReferencingBase + +function mixin {}>(base: Base) { +>mixin : {}>(base: Base) => { new (...args: any[]): (Anonymous class); value: number; prototype: mixin.(Anonymous class); } & Base +>args : any[] +>base : Base + + return class extends base { +>class extends base { static value = 1; value = 2; } : { new (...args: any[]): (Anonymous class); value: number; prototype: mixin.(Anonymous class); } & Base +>base : {} + + static value = 1; +>value : number +>1 : 1 + + value = 2; +>value : number +>2 : 2 + + }; +} + +class Mixed extends mixin(NestedBase) {} +>Mixed : Mixed +>mixin(NestedBase) : mixin.(Anonymous class) & NestedBase +>mixin : {}>(base: Base) => { new (...args: any[]): (Anonymous class); value: number; prototype: mixin.(Anonymous class); } & Base +>NestedBase : typeof NestedBase + +const mixedStaticValue: number = Mixed.value; +>mixedStaticValue : number +>Mixed.value : number +>Mixed : typeof Mixed +>value : number + +const mixedInstanceValue: number = new Mixed().value; +>mixedInstanceValue : number +>new Mixed().value : number +>new Mixed() : Mixed +>Mixed : typeof Mixed +>value : number + +declare function makeBase(value: number): typeof NestedBase; +>makeBase : (value: number) => typeof NestedBase +>value : number +>NestedBase : typeof NestedBase + +class InvalidBaseArgument extends makeBase("invalid") {} +>InvalidBaseArgument : InvalidBaseArgument +>makeBase("invalid") : NestedBase +>makeBase : (value: number) => typeof NestedBase +>"invalid" : "invalid" + +const InvalidExpressionArgument = class extends makeBase("invalid") {}; +>InvalidExpressionArgument : typeof InvalidExpressionArgument +>class extends makeBase("invalid") {} : typeof InvalidExpressionArgument +>makeBase("invalid") : NestedBase +>makeBase : (value: number) => typeof NestedBase +>"invalid" : "invalid" + +declare function makeInvalidBase(value: number): number; +>makeInvalidBase : (value: number) => number +>value : number + +class InvalidConstructor extends makeInvalidBase("invalid") {} +>InvalidConstructor : InvalidConstructor +>makeInvalidBase("invalid") : number +>makeInvalidBase : (value: number) => number +>"invalid" : "invalid" + diff --git a/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt b/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt index 1d2d3f5568b0f..9a749f4c13ab3 100644 --- a/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt @@ -1,7 +1,10 @@ classExpressionWithDecorator1.ts(1,9): error TS1206: Decorators are not valid here. +classExpressionWithDecorator1.ts(1,10): error TS2304: Cannot find name 'decorate'. -==== classExpressionWithDecorator1.ts (1 errors) ==== +==== classExpressionWithDecorator1.ts (2 errors) ==== var v = @decorate class C { static p = 1 }; ~ -!!! error TS1206: Decorators are not valid here. \ No newline at end of file +!!! error TS1206: Decorators are not valid here. + ~~~~~~~~ +!!! error TS2304: Cannot find name 'decorate'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.errors.txt b/tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.errors.txt deleted file mode 100644 index 502975549c191..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.errors.txt +++ /dev/null @@ -1,24 +0,0 @@ -classVarianceResolveCircularity2.ts(7,5): error TS7022: 'Value' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - - -==== classVarianceResolveCircularity2.ts (1 errors) ==== - // Issue #52813 - - export {}; - - class Bar { - num!: number; - Value = callme(new Foo(this)).bar.num; - ~~~~~ -!!! error TS7022: 'Value' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - Field: number = callme(new Foo(this)).bar.num; - } - declare function callme(x: Foo): Foo; - declare function callme(x: object): string; - - class Foo { - bar!: Bar; - constructor(bar: Bar) { - this.bar = bar; - } - } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.types b/tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.types index d1bd8c01269ff..1aa4a1481a92c 100644 --- a/tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.types +++ b/tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.types @@ -12,7 +12,7 @@ class Bar { >num : number Value = callme(new Foo(this)).bar.num; ->Value : any +>Value : number >callme(new Foo(this)).bar.num : number >callme(new Foo(this)).bar : Bar >callme(new Foo(this)) : Foo diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..a61c1f0f60680 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).symbols @@ -0,0 +1,66 @@ +//// [tests/cases/compiler/clonedTypeParameterUnionOrder.ts] //// + +=== a.ts === +interface Pair { a: A; b: B } +>Pair : Symbol(Pair, Decl(a.ts, 0, 0)) +>A : Symbol(A, Decl(a.ts, 0, 15)) +>B : Symbol(B, Decl(a.ts, 0, 17)) +>a : Symbol(Pair.a, Decl(a.ts, 0, 22)) +>A : Symbol(A, Decl(a.ts, 0, 15)) +>b : Symbol(Pair.b, Decl(a.ts, 0, 28)) +>B : Symbol(B, Decl(a.ts, 0, 17)) + +interface Box { m(x: T): Pair } +>Box : Symbol(Box, Decl(a.ts, 0, 35)) +>U : Symbol(U, Decl(a.ts, 1, 14)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>x : Symbol(x, Decl(a.ts, 1, 24)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>Pair : Symbol(Pair, Decl(a.ts, 0, 0)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>U : Symbol(U, Decl(a.ts, 1, 14)) + +declare function call(f: (x: A) => R): (x: A) => R; +>call : Symbol(call, Decl(a.ts, 1, 43)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) +>f : Symbol(f, Decl(a.ts, 2, 28)) +>x : Symbol(x, Decl(a.ts, 2, 32)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) +>x : Symbol(x, Decl(a.ts, 2, 46)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) + +declare const bs: Box; +>bs : Symbol(bs, Decl(a.ts, 3, 13)) +>Box : Symbol(Box, Decl(a.ts, 0, 35)) + +declare const bn: Box; +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>Box : Symbol(Box, Decl(a.ts, 0, 35)) + +const n = call(bn.m); +>n : Symbol(n, Decl(a.ts, 5, 5)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bn.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) + +=== b.ts === +declare const c: boolean; +>c : Symbol(c, Decl(b.ts, 0, 13)) + +const r = c ? call(bs.m) : call(bn.m); +>r : Symbol(r, Decl(b.ts, 1, 5)) +>c : Symbol(c, Decl(b.ts, 0, 13)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bs.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bs : Symbol(bs, Decl(a.ts, 3, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bn.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) + diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types new file mode 100644 index 0000000000000..8b93c5f3f8987 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/clonedTypeParameterUnionOrder.ts] //// + +=== a.ts === +interface Pair { a: A; b: B } +>a : A +>b : B + +interface Box { m(x: T): Pair } +>m : (x: T) => Pair +>x : T + +declare function call(f: (x: A) => R): (x: A) => R; +>call : (f: (x: A) => R) => (x: A) => R +>f : (x: A) => R +>x : A +>x : A + +declare const bs: Box; +>bs : Box + +declare const bn: Box; +>bn : Box + +const n = call(bn.m); +>n : (x: T) => Pair +>call(bn.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bn.m : (x: T) => Pair +>bn : Box +>m : (x: T) => Pair + +=== b.ts === +declare const c: boolean; +>c : boolean + +const r = c ? call(bs.m) : call(bn.m); +>r : ((x: T) => Pair) | ((x: T) => Pair) +>c ? call(bs.m) : call(bn.m) : ((x: T) => Pair) | ((x: T) => Pair) +>c : boolean +>call(bs.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bs.m : (x: T) => Pair +>bs : Box +>m : (x: T) => Pair +>call(bn.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bn.m : (x: T) => Pair +>bn : Box +>m : (x: T) => Pair + diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).symbols b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).symbols new file mode 100644 index 0000000000000..a61c1f0f60680 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).symbols @@ -0,0 +1,66 @@ +//// [tests/cases/compiler/clonedTypeParameterUnionOrder.ts] //// + +=== a.ts === +interface Pair { a: A; b: B } +>Pair : Symbol(Pair, Decl(a.ts, 0, 0)) +>A : Symbol(A, Decl(a.ts, 0, 15)) +>B : Symbol(B, Decl(a.ts, 0, 17)) +>a : Symbol(Pair.a, Decl(a.ts, 0, 22)) +>A : Symbol(A, Decl(a.ts, 0, 15)) +>b : Symbol(Pair.b, Decl(a.ts, 0, 28)) +>B : Symbol(B, Decl(a.ts, 0, 17)) + +interface Box { m(x: T): Pair } +>Box : Symbol(Box, Decl(a.ts, 0, 35)) +>U : Symbol(U, Decl(a.ts, 1, 14)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>x : Symbol(x, Decl(a.ts, 1, 24)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>Pair : Symbol(Pair, Decl(a.ts, 0, 0)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>U : Symbol(U, Decl(a.ts, 1, 14)) + +declare function call(f: (x: A) => R): (x: A) => R; +>call : Symbol(call, Decl(a.ts, 1, 43)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) +>f : Symbol(f, Decl(a.ts, 2, 28)) +>x : Symbol(x, Decl(a.ts, 2, 32)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) +>x : Symbol(x, Decl(a.ts, 2, 46)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) + +declare const bs: Box; +>bs : Symbol(bs, Decl(a.ts, 3, 13)) +>Box : Symbol(Box, Decl(a.ts, 0, 35)) + +declare const bn: Box; +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>Box : Symbol(Box, Decl(a.ts, 0, 35)) + +const n = call(bn.m); +>n : Symbol(n, Decl(a.ts, 5, 5)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bn.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) + +=== b.ts === +declare const c: boolean; +>c : Symbol(c, Decl(b.ts, 0, 13)) + +const r = c ? call(bs.m) : call(bn.m); +>r : Symbol(r, Decl(b.ts, 1, 5)) +>c : Symbol(c, Decl(b.ts, 0, 13)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bs.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bs : Symbol(bs, Decl(a.ts, 3, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bn.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) + diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).types new file mode 100644 index 0000000000000..8b93c5f3f8987 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).types @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/clonedTypeParameterUnionOrder.ts] //// + +=== a.ts === +interface Pair { a: A; b: B } +>a : A +>b : B + +interface Box { m(x: T): Pair } +>m : (x: T) => Pair +>x : T + +declare function call(f: (x: A) => R): (x: A) => R; +>call : (f: (x: A) => R) => (x: A) => R +>f : (x: A) => R +>x : A +>x : A + +declare const bs: Box; +>bs : Box + +declare const bn: Box; +>bn : Box + +const n = call(bn.m); +>n : (x: T) => Pair +>call(bn.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bn.m : (x: T) => Pair +>bn : Box +>m : (x: T) => Pair + +=== b.ts === +declare const c: boolean; +>c : boolean + +const r = c ? call(bs.m) : call(bn.m); +>r : ((x: T) => Pair) | ((x: T) => Pair) +>c ? call(bs.m) : call(bn.m) : ((x: T) => Pair) | ((x: T) => Pair) +>c : boolean +>call(bs.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bs.m : (x: T) => Pair +>bs : Box +>m : (x: T) => Pair +>call(bn.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bn.m : (x: T) => Pair +>bn : Box +>m : (x: T) => Pair + diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..a61c1f0f60680 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).symbols @@ -0,0 +1,66 @@ +//// [tests/cases/compiler/clonedTypeParameterUnionOrder.ts] //// + +=== a.ts === +interface Pair { a: A; b: B } +>Pair : Symbol(Pair, Decl(a.ts, 0, 0)) +>A : Symbol(A, Decl(a.ts, 0, 15)) +>B : Symbol(B, Decl(a.ts, 0, 17)) +>a : Symbol(Pair.a, Decl(a.ts, 0, 22)) +>A : Symbol(A, Decl(a.ts, 0, 15)) +>b : Symbol(Pair.b, Decl(a.ts, 0, 28)) +>B : Symbol(B, Decl(a.ts, 0, 17)) + +interface Box { m(x: T): Pair } +>Box : Symbol(Box, Decl(a.ts, 0, 35)) +>U : Symbol(U, Decl(a.ts, 1, 14)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>x : Symbol(x, Decl(a.ts, 1, 24)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>Pair : Symbol(Pair, Decl(a.ts, 0, 0)) +>T : Symbol(T, Decl(a.ts, 1, 21)) +>U : Symbol(U, Decl(a.ts, 1, 14)) + +declare function call(f: (x: A) => R): (x: A) => R; +>call : Symbol(call, Decl(a.ts, 1, 43)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) +>f : Symbol(f, Decl(a.ts, 2, 28)) +>x : Symbol(x, Decl(a.ts, 2, 32)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) +>x : Symbol(x, Decl(a.ts, 2, 46)) +>A : Symbol(A, Decl(a.ts, 2, 22)) +>R : Symbol(R, Decl(a.ts, 2, 24)) + +declare const bs: Box; +>bs : Symbol(bs, Decl(a.ts, 3, 13)) +>Box : Symbol(Box, Decl(a.ts, 0, 35)) + +declare const bn: Box; +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>Box : Symbol(Box, Decl(a.ts, 0, 35)) + +const n = call(bn.m); +>n : Symbol(n, Decl(a.ts, 5, 5)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bn.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) + +=== b.ts === +declare const c: boolean; +>c : Symbol(c, Decl(b.ts, 0, 13)) + +const r = c ? call(bs.m) : call(bn.m); +>r : Symbol(r, Decl(b.ts, 1, 5)) +>c : Symbol(c, Decl(b.ts, 0, 13)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bs.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bs : Symbol(bs, Decl(a.ts, 3, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>call : Symbol(call, Decl(a.ts, 1, 43)) +>bn.m : Symbol(Box.m, Decl(a.ts, 1, 18)) +>bn : Symbol(bn, Decl(a.ts, 4, 13)) +>m : Symbol(Box.m, Decl(a.ts, 1, 18)) + diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..8b93c5f3f8987 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/clonedTypeParameterUnionOrder.ts] //// + +=== a.ts === +interface Pair { a: A; b: B } +>a : A +>b : B + +interface Box { m(x: T): Pair } +>m : (x: T) => Pair +>x : T + +declare function call(f: (x: A) => R): (x: A) => R; +>call : (f: (x: A) => R) => (x: A) => R +>f : (x: A) => R +>x : A +>x : A + +declare const bs: Box; +>bs : Box + +declare const bn: Box; +>bn : Box + +const n = call(bn.m); +>n : (x: T) => Pair +>call(bn.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bn.m : (x: T) => Pair +>bn : Box +>m : (x: T) => Pair + +=== b.ts === +declare const c: boolean; +>c : boolean + +const r = c ? call(bs.m) : call(bn.m); +>r : ((x: T) => Pair) | ((x: T) => Pair) +>c ? call(bs.m) : call(bn.m) : ((x: T) => Pair) | ((x: T) => Pair) +>c : boolean +>call(bs.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bs.m : (x: T) => Pair +>bs : Box +>m : (x: T) => Pair +>call(bn.m) : (x: T) => Pair +>call : (f: (x: A) => R) => (x: A) => R +>bn.m : (x: T) => Pair +>bn : Box +>m : (x: T) => Pair + diff --git a/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt b/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt index 2a4fb0967ee33..8b242f6fc3238 100644 --- a/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt @@ -6,7 +6,7 @@ immutable.ts(289,22): error TS2320: Interface 'Indexed' cannot simultaneously immutable.ts(305,22): error TS2320: Interface 'Set' cannot simultaneously extend types 'Seq' and 'Set'. Named property 'size' of types 'Seq' and 'Set' are not identical. immutable.ts(323,20): error TS2430: Interface 'Seq' incorrectly extends interface 'Collection'. - The types returned by 'map(...).size' are incompatible between these types. + The types returned by 'map(...).filter(...).size' are incompatible between these types. Type 'number | undefined' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. immutable.ts(341,22): error TS2430: Interface 'Keyed' incorrectly extends interface 'Collection'. @@ -382,7 +382,7 @@ immutable.ts(391,22): error TS2430: Interface 'Set' incorrectly extends inter export interface Seq extends Collection { ~~~ !!! error TS2430: Interface 'Seq' incorrectly extends interface 'Collection'. -!!! error TS2430: The types returned by 'map(...).size' are incompatible between these types. +!!! error TS2430: The types returned by 'map(...).filter(...).size' are incompatible between these types. !!! error TS2430: Type 'number | undefined' is not assignable to type 'number'. !!! error TS2430: Type 'undefined' is not assignable to type 'number'. readonly size: number | undefined; diff --git a/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..cbd22ad10c410 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).symbols @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts] //// + +=== constAssertionBindingPatternQueryOrder.ts === +declare function settle(fn: () => T): Promise<{ [K in keyof T]: [Awaited] }>; +>settle : Symbol(settle, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 0)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>fn : Symbol(fn, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 54)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>K : Symbol(K, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 79)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>K : Symbol(K, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 79)) + +async function f() { +>f : Symbol(f, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 113)) + + const [[a], b] = await settle(() => [Promise.resolve(0), Promise.reject(1)] as const); +>a : Symbol(a, Decl(constAssertionBindingPatternQueryOrder.ts, 3, 10)) +>b : Symbol(b, Decl(constAssertionBindingPatternQueryOrder.ts, 3, 13)) +>settle : Symbol(settle, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 0)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --)) +>const : Symbol(const) +} + diff --git a/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..d263c604b0052 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts] //// + +=== constAssertionBindingPatternQueryOrder.ts === +declare function settle(fn: () => T): Promise<{ [K in keyof T]: [Awaited] }>; +>settle : (fn: () => T) => Promise<{ [K in keyof T]: [Awaited]; }> +>fn : () => T + +async function f() { +>f : () => Promise + + const [[a], b] = await settle(() => [Promise.resolve(0), Promise.reject(1)] as const); +>a : number +>b : [never] +>await settle(() => [Promise.resolve(0), Promise.reject(1)] as const) : [[number], [never]] +>settle(() => [Promise.resolve(0), Promise.reject(1)] as const) : Promise<[[number], [never]]> +>settle : (fn: () => T) => Promise<{ [K in keyof T]: [Awaited]; }> +>() => [Promise.resolve(0), Promise.reject(1)] as const : () => [Promise, Promise] +>[Promise.resolve(0), Promise.reject(1)] as const : [Promise, Promise] +>[Promise.resolve(0), Promise.reject(1)] : [Promise, Promise] +>Promise.resolve(0) : Promise +>Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } +>Promise : PromiseConstructor +>resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } +>0 : 0 +>Promise.reject(1) : Promise +>Promise.reject : (reason?: any) => Promise +>Promise : PromiseConstructor +>reject : (reason?: any) => Promise +>1 : 1 +} + diff --git a/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..cbd22ad10c410 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).symbols @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts] //// + +=== constAssertionBindingPatternQueryOrder.ts === +declare function settle(fn: () => T): Promise<{ [K in keyof T]: [Awaited] }>; +>settle : Symbol(settle, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 0)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>fn : Symbol(fn, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 54)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>K : Symbol(K, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 79)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 24)) +>K : Symbol(K, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 79)) + +async function f() { +>f : Symbol(f, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 113)) + + const [[a], b] = await settle(() => [Promise.resolve(0), Promise.reject(1)] as const); +>a : Symbol(a, Decl(constAssertionBindingPatternQueryOrder.ts, 3, 10)) +>b : Symbol(b, Decl(constAssertionBindingPatternQueryOrder.ts, 3, 13)) +>settle : Symbol(settle, Decl(constAssertionBindingPatternQueryOrder.ts, 0, 0)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --)) +>const : Symbol(const) +} + diff --git a/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..d263c604b0052 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts] //// + +=== constAssertionBindingPatternQueryOrder.ts === +declare function settle(fn: () => T): Promise<{ [K in keyof T]: [Awaited] }>; +>settle : (fn: () => T) => Promise<{ [K in keyof T]: [Awaited]; }> +>fn : () => T + +async function f() { +>f : () => Promise + + const [[a], b] = await settle(() => [Promise.resolve(0), Promise.reject(1)] as const); +>a : number +>b : [never] +>await settle(() => [Promise.resolve(0), Promise.reject(1)] as const) : [[number], [never]] +>settle(() => [Promise.resolve(0), Promise.reject(1)] as const) : Promise<[[number], [never]]> +>settle : (fn: () => T) => Promise<{ [K in keyof T]: [Awaited]; }> +>() => [Promise.resolve(0), Promise.reject(1)] as const : () => [Promise, Promise] +>[Promise.resolve(0), Promise.reject(1)] as const : [Promise, Promise] +>[Promise.resolve(0), Promise.reject(1)] : [Promise, Promise] +>Promise.resolve(0) : Promise +>Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } +>Promise : PromiseConstructor +>resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } +>0 : 0 +>Promise.reject(1) : Promise +>Promise.reject : (reason?: any) => Promise +>Promise : PromiseConstructor +>reject : (reason?: any) => Promise +>1 : 1 +} + diff --git a/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt b/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt index 81ac42365af10..2852054f9325f 100644 --- a/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt @@ -1,5 +1,4 @@ constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2503: Cannot find namespace 'module'. -constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. constructorWithIncompleteTypeAnnotation.ts(11,19): error TS1005: ';' expected. constructorWithIncompleteTypeAnnotation.ts(22,35): error TS1005: ')' expected. constructorWithIncompleteTypeAnnotation.ts(22,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. @@ -95,7 +94,7 @@ constructorWithIncompleteTypeAnnotation.ts(259,55): error TS1005: ';' expected. constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected. -==== constructorWithIncompleteTypeAnnotation.ts (95 errors) ==== +==== constructorWithIncompleteTypeAnnotation.ts (94 errors) ==== declare module "fs" { export class File { constructor(filename: string); @@ -109,8 +108,6 @@ constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or import fs = module("fs"); ~~~~~~ !!! error TS2503: Cannot find namespace 'module'. - ~~~~~~ -!!! error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. ~ !!! error TS1005: ';' expected. diff --git a/tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.symbols b/tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.symbols new file mode 100644 index 0000000000000..3169a3c3cbd08 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.symbols @@ -0,0 +1,150 @@ +//// [tests/cases/compiler/contextualCheckInDiscardedCycle.ts] //// + +=== returnTypeCycle.ts === +// Callbacks contextually checked while a cycle is in progress are checked +// again once it is discarded, with their contextual parameter types. + +declare function useCallback(callback: T): T; +>useCallback : Symbol(useCallback, Decl(returnTypeCycle.ts, 0, 0)) +>T : Symbol(T, Decl(returnTypeCycle.ts, 3, 29)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>callback : Symbol(callback, Decl(returnTypeCycle.ts, 3, 49)) +>T : Symbol(T, Decl(returnTypeCycle.ts, 3, 29)) +>T : Symbol(T, Decl(returnTypeCycle.ts, 3, 29)) + +declare function refreshAll(options: { ids: string[]; extra: T }): Promise; +>refreshAll : Symbol(refreshAll, Decl(returnTypeCycle.ts, 3, 65)) +>T : Symbol(T, Decl(returnTypeCycle.ts, 4, 28)) +>options : Symbol(options, Decl(returnTypeCycle.ts, 4, 31)) +>ids : Symbol(ids, Decl(returnTypeCycle.ts, 4, 41)) +>extra : Symbol(extra, Decl(returnTypeCycle.ts, 4, 56)) +>T : Symbol(T, Decl(returnTypeCycle.ts, 4, 28)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>T : Symbol(T, Decl(returnTypeCycle.ts, 4, 28)) + +interface View { +>View : Symbol(View, Decl(returnTypeCycle.ts, 4, 81)) + + refresh: (force?: boolean) => Promise; +>refresh : Symbol(View.refresh, Decl(returnTypeCycle.ts, 6, 16)) +>force : Symbol(force, Decl(returnTypeCycle.ts, 7, 14)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +} + +declare const items: { id: string }[]; +>items : Symbol(items, Decl(returnTypeCycle.ts, 10, 13)) +>id : Symbol(id, Decl(returnTypeCycle.ts, 10, 22)) + +function useView(): View { +>useView : Symbol(useView, Decl(returnTypeCycle.ts, 10, 38)) +>View : Symbol(View, Decl(returnTypeCycle.ts, 4, 81)) + + const refresh = useCallback((force?: boolean) => +>refresh : Symbol(refresh, Decl(returnTypeCycle.ts, 13, 9)) +>useCallback : Symbol(useCallback, Decl(returnTypeCycle.ts, 0, 0)) +>force : Symbol(force, Decl(returnTypeCycle.ts, 13, 33)) + + refreshAll({ +>refreshAll : Symbol(refreshAll, Decl(returnTypeCycle.ts, 3, 65)) + + ids: items.map(({ id }) => id), +>ids : Symbol(ids, Decl(returnTypeCycle.ts, 14, 20)) +>items.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>items : Symbol(items, Decl(returnTypeCycle.ts, 10, 13)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>id : Symbol(id, Decl(returnTypeCycle.ts, 15, 29)) +>id : Symbol(id, Decl(returnTypeCycle.ts, 15, 29)) + + extra: 1, +>extra : Symbol(extra, Decl(returnTypeCycle.ts, 15, 43)) + + })); + return { refresh }; +>refresh : Symbol(refresh, Decl(returnTypeCycle.ts, 18, 12)) +} + +=== yieldOperandCycle.ts === +interface Eff { +>Eff : Symbol(Eff, Decl(yieldOperandCycle.ts, 0, 0)) +>A : Symbol(A, Decl(yieldOperandCycle.ts, 0, 14)) +>E : Symbol(E, Decl(yieldOperandCycle.ts, 0, 16)) + + [Symbol.iterator](): Generator, A, any>; +>[Symbol.iterator] : Symbol(Eff[Symbol.iterator], Decl(yieldOperandCycle.ts, 0, 21)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>Eff : Symbol(Eff, Decl(yieldOperandCycle.ts, 0, 0)) +>A : Symbol(A, Decl(yieldOperandCycle.ts, 0, 14)) +>E : Symbol(E, Decl(yieldOperandCycle.ts, 0, 16)) +>A : Symbol(A, Decl(yieldOperandCycle.ts, 0, 14)) + + pipe(f: (self: Eff) => B): B; +>pipe : Symbol(Eff.pipe, Decl(yieldOperandCycle.ts, 1, 54)) +>B : Symbol(B, Decl(yieldOperandCycle.ts, 2, 9)) +>f : Symbol(f, Decl(yieldOperandCycle.ts, 2, 12)) +>self : Symbol(self, Decl(yieldOperandCycle.ts, 2, 16)) +>Eff : Symbol(Eff, Decl(yieldOperandCycle.ts, 0, 0)) +>A : Symbol(A, Decl(yieldOperandCycle.ts, 0, 14)) +>E : Symbol(E, Decl(yieldOperandCycle.ts, 0, 16)) +>B : Symbol(B, Decl(yieldOperandCycle.ts, 2, 9)) +>B : Symbol(B, Decl(yieldOperandCycle.ts, 2, 9)) +} +declare function mapError(f: (e: E) => E2): (self: Eff) => Eff; +>mapError : Symbol(mapError, Decl(yieldOperandCycle.ts, 3, 1)) +>E : Symbol(E, Decl(yieldOperandCycle.ts, 4, 26)) +>E2 : Symbol(E2, Decl(yieldOperandCycle.ts, 4, 28)) +>f : Symbol(f, Decl(yieldOperandCycle.ts, 4, 33)) +>e : Symbol(e, Decl(yieldOperandCycle.ts, 4, 37)) +>E : Symbol(E, Decl(yieldOperandCycle.ts, 4, 26)) +>E2 : Symbol(E2, Decl(yieldOperandCycle.ts, 4, 28)) +>A : Symbol(A, Decl(yieldOperandCycle.ts, 4, 52)) +>self : Symbol(self, Decl(yieldOperandCycle.ts, 4, 55)) +>Eff : Symbol(Eff, Decl(yieldOperandCycle.ts, 0, 0)) +>A : Symbol(A, Decl(yieldOperandCycle.ts, 4, 52)) +>E : Symbol(E, Decl(yieldOperandCycle.ts, 4, 26)) +>Eff : Symbol(Eff, Decl(yieldOperandCycle.ts, 0, 0)) +>A : Symbol(A, Decl(yieldOperandCycle.ts, 4, 52)) +>E2 : Symbol(E2, Decl(yieldOperandCycle.ts, 4, 28)) + +declare function fn(body: (input: number) => Generator): (input: number) => Eff; +>fn : Symbol(fn, Decl(yieldOperandCycle.ts, 4, 86)) +>Y : Symbol(Y, Decl(yieldOperandCycle.ts, 5, 20)) +>R : Symbol(R, Decl(yieldOperandCycle.ts, 5, 22)) +>body : Symbol(body, Decl(yieldOperandCycle.ts, 5, 26)) +>input : Symbol(input, Decl(yieldOperandCycle.ts, 5, 33)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>Y : Symbol(Y, Decl(yieldOperandCycle.ts, 5, 20)) +>R : Symbol(R, Decl(yieldOperandCycle.ts, 5, 22)) +>input : Symbol(input, Decl(yieldOperandCycle.ts, 5, 75)) +>Eff : Symbol(Eff, Decl(yieldOperandCycle.ts, 0, 0)) +>R : Symbol(R, Decl(yieldOperandCycle.ts, 5, 22)) + +declare function make(s: T): T; +>make : Symbol(make, Decl(yieldOperandCycle.ts, 5, 107)) +>T : Symbol(T, Decl(yieldOperandCycle.ts, 6, 22)) +>s : Symbol(s, Decl(yieldOperandCycle.ts, 6, 40)) +>T : Symbol(T, Decl(yieldOperandCycle.ts, 6, 22)) +>T : Symbol(T, Decl(yieldOperandCycle.ts, 6, 22)) + +declare const uuid: Eff; +>uuid : Symbol(uuid, Decl(yieldOperandCycle.ts, 7, 13)) +>Eff : Symbol(Eff, Decl(yieldOperandCycle.ts, 0, 0)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + +fn(function* (input) { +>fn : Symbol(fn, Decl(yieldOperandCycle.ts, 4, 86)) +>input : Symbol(input, Decl(yieldOperandCycle.ts, 9, 14)) + + make(yield* uuid.pipe(mapError((cause) => ({ cause })))); +>make : Symbol(make, Decl(yieldOperandCycle.ts, 5, 107)) +>uuid.pipe : Symbol(Eff.pipe, Decl(yieldOperandCycle.ts, 1, 54)) +>uuid : Symbol(uuid, Decl(yieldOperandCycle.ts, 7, 13)) +>pipe : Symbol(Eff.pipe, Decl(yieldOperandCycle.ts, 1, 54)) +>mapError : Symbol(mapError, Decl(yieldOperandCycle.ts, 3, 1)) +>cause : Symbol(cause, Decl(yieldOperandCycle.ts, 10, 36)) +>cause : Symbol(cause, Decl(yieldOperandCycle.ts, 10, 48)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.types b/tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.types new file mode 100644 index 0000000000000..7506ea748391e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.types @@ -0,0 +1,117 @@ +//// [tests/cases/compiler/contextualCheckInDiscardedCycle.ts] //// + +=== returnTypeCycle.ts === +// Callbacks contextually checked while a cycle is in progress are checked +// again once it is discarded, with their contextual parameter types. + +declare function useCallback(callback: T): T; +>useCallback : (callback: T) => T +>callback : T + +declare function refreshAll(options: { ids: string[]; extra: T }): Promise; +>refreshAll : (options: { ids: string[]; extra: T; }) => Promise +>options : { ids: string[]; extra: T; } +>ids : string[] +>extra : T + +interface View { + refresh: (force?: boolean) => Promise; +>refresh : (force?: boolean) => Promise +>force : boolean | undefined +} + +declare const items: { id: string }[]; +>items : { id: string; }[] +>id : string + +function useView(): View { +>useView : () => View + + const refresh = useCallback((force?: boolean) => +>refresh : (force?: boolean) => Promise +>useCallback((force?: boolean) => refreshAll({ ids: items.map(({ id }) => id), extra: 1, })) : (force?: boolean) => Promise +>useCallback : (callback: T) => T +>(force?: boolean) => refreshAll({ ids: items.map(({ id }) => id), extra: 1, }) : (force?: boolean) => Promise +>force : boolean | undefined + + refreshAll({ +>refreshAll({ ids: items.map(({ id }) => id), extra: 1, }) : Promise +>refreshAll : (options: { ids: string[]; extra: T; }) => Promise +>{ ids: items.map(({ id }) => id), extra: 1, } : { ids: string[]; extra: number; } + + ids: items.map(({ id }) => id), +>ids : string[] +>items.map(({ id }) => id) : string[] +>items.map : (callbackfn: (value: { id: string; }, index: number, array: { id: string; }[]) => U, thisArg?: any) => U[] +>items : { id: string; }[] +>map : (callbackfn: (value: { id: string; }, index: number, array: { id: string; }[]) => U, thisArg?: any) => U[] +>({ id }) => id : ({ id }: { id: string; }) => string +>id : string +>id : string + + extra: 1, +>extra : number +>1 : 1 + + })); + return { refresh }; +>{ refresh } : { refresh: (force?: boolean) => Promise; } +>refresh : (force?: boolean) => Promise +} + +=== yieldOperandCycle.ts === +interface Eff { + [Symbol.iterator](): Generator, A, any>; +>[Symbol.iterator] : () => Generator, A, any> +>Symbol.iterator : unique symbol +>Symbol : SymbolConstructor +>iterator : unique symbol + + pipe(f: (self: Eff) => B): B; +>pipe : (f: (self: Eff) => B) => B +>f : (self: Eff) => B +>self : Eff +} +declare function mapError(f: (e: E) => E2): (self: Eff) => Eff; +>mapError : (f: (e: E) => E2) => (self: Eff) => Eff +>f : (e: E) => E2 +>e : E +>self : Eff + +declare function fn(body: (input: number) => Generator): (input: number) => Eff; +>fn : (body: (input: number) => Generator) => (input: number) => Eff +>body : (input: number) => Generator +>input : number +>input : number + +declare function make(s: T): T; +>make : (s: T) => T +>s : T + +declare const uuid: Eff; +>uuid : Eff + +fn(function* (input) { +>fn(function* (input) { make(yield* uuid.pipe(mapError((cause) => ({ cause }))));}) : (input: number) => Eff +>fn : (body: (input: number) => Generator) => (input: number) => Eff +>function* (input) { make(yield* uuid.pipe(mapError((cause) => ({ cause }))));} : (input: number) => Generator, void, any> +>input : number + + make(yield* uuid.pipe(mapError((cause) => ({ cause })))); +>make(yield* uuid.pipe(mapError((cause) => ({ cause })))) : string +>make : (s: T) => T +>yield* uuid.pipe(mapError((cause) => ({ cause }))) : string +>uuid.pipe(mapError((cause) => ({ cause }))) : Eff +>uuid.pipe : (f: (self: Eff) => B) => B +>uuid : Eff +>pipe : (f: (self: Eff) => B) => B +>mapError((cause) => ({ cause })) : (self: Eff) => Eff +>mapError : (f: (e: E) => E2) => (self: Eff) => Eff +>(cause) => ({ cause }) : (cause: Error) => { cause: Error; } +>cause : Error +>({ cause }) : { cause: Error; } +>{ cause } : { cause: Error; } +>cause : Error + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.symbols b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.symbols new file mode 100644 index 0000000000000..695dd85162edd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.symbols @@ -0,0 +1,181 @@ +//// [tests/cases/compiler/contextualCheckReentryAfterParameters.ts] //// + +=== contextualCheckReentryAfterParameters.ts === +// Instantiating the type predicate inside the nested callback re-enters the +// contextual check of the enclosing functions through their outer type +// parameters. That must not discard the parameter types assigned to them. + +type Surface = { id: string; kind: "file"; path: string } | { id: string; kind: "terminal" }; +>Surface : Symbol(Surface, Decl(contextualCheckReentryAfterParameters.ts, 0, 0)) +>id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 4, 16)) +>kind : Symbol(kind, Decl(contextualCheckReentryAfterParameters.ts, 4, 28)) +>path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 4, 42)) +>id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 4, 61)) +>kind : Symbol(kind, Decl(contextualCheckReentryAfterParameters.ts, 4, 73)) + +interface Panel { +>Panel : Symbol(Panel, Decl(contextualCheckReentryAfterParameters.ts, 4, 93)) + + surfaces: Surface[]; +>surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>Surface : Symbol(Surface, Decl(contextualCheckReentryAfterParameters.ts, 0, 0)) +} +interface Store { +>Store : Symbol(Store, Decl(contextualCheckReentryAfterParameters.ts, 7, 1)) + + panel: Panel; +>panel : Symbol(Store.panel, Decl(contextualCheckReentryAfterParameters.ts, 8, 17)) +>Panel : Symbol(Panel, Decl(contextualCheckReentryAfterParameters.ts, 4, 93)) + + openFile: (path: string) => void; +>openFile : Symbol(Store.openFile, Decl(contextualCheckReentryAfterParameters.ts, 9, 17)) +>path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 10, 15)) + + close: (id: string) => void; +>close : Symbol(Store.close, Decl(contextualCheckReentryAfterParameters.ts, 10, 37)) +>id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 11, 12)) +} +type Creator = (set: (update: (state: T) => Partial) => void) => T; +>Creator : Symbol(Creator, Decl(contextualCheckReentryAfterParameters.ts, 12, 1)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 13, 13)) +>set : Symbol(set, Decl(contextualCheckReentryAfterParameters.ts, 13, 19)) +>update : Symbol(update, Decl(contextualCheckReentryAfterParameters.ts, 13, 25)) +>state : Symbol(state, Decl(contextualCheckReentryAfterParameters.ts, 13, 34)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 13, 13)) +>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 13, 13)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 13, 13)) + +declare function create(init: Creator): T; +>create : Symbol(create, Decl(contextualCheckReentryAfterParameters.ts, 13, 73)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 14, 24)) +>init : Symbol(init, Decl(contextualCheckReentryAfterParameters.ts, 14, 27)) +>Creator : Symbol(Creator, Decl(contextualCheckReentryAfterParameters.ts, 12, 1)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 14, 24)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 14, 24)) + +declare function wrap(init: Creator): Creator; +>wrap : Symbol(wrap, Decl(contextualCheckReentryAfterParameters.ts, 14, 48)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 15, 22)) +>init : Symbol(init, Decl(contextualCheckReentryAfterParameters.ts, 15, 25)) +>Creator : Symbol(Creator, Decl(contextualCheckReentryAfterParameters.ts, 12, 1)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 15, 22)) +>Creator : Symbol(Creator, Decl(contextualCheckReentryAfterParameters.ts, 12, 1)) +>T : Symbol(T, Decl(contextualCheckReentryAfterParameters.ts, 15, 22)) + +const update = (state: Store, updater: (current: Panel) => Panel): Partial => ({ panel: updater(state.panel) }); +>update : Symbol(update, Decl(contextualCheckReentryAfterParameters.ts, 17, 5)) +>state : Symbol(state, Decl(contextualCheckReentryAfterParameters.ts, 17, 16)) +>Store : Symbol(Store, Decl(contextualCheckReentryAfterParameters.ts, 7, 1)) +>updater : Symbol(updater, Decl(contextualCheckReentryAfterParameters.ts, 17, 29)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 17, 40)) +>Panel : Symbol(Panel, Decl(contextualCheckReentryAfterParameters.ts, 4, 93)) +>Panel : Symbol(Panel, Decl(contextualCheckReentryAfterParameters.ts, 4, 93)) +>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) +>Store : Symbol(Store, Decl(contextualCheckReentryAfterParameters.ts, 7, 1)) +>panel : Symbol(panel, Decl(contextualCheckReentryAfterParameters.ts, 17, 87)) +>updater : Symbol(updater, Decl(contextualCheckReentryAfterParameters.ts, 17, 29)) +>state.panel : Symbol(Store.panel, Decl(contextualCheckReentryAfterParameters.ts, 8, 17)) +>state : Symbol(state, Decl(contextualCheckReentryAfterParameters.ts, 17, 16)) +>panel : Symbol(Store.panel, Decl(contextualCheckReentryAfterParameters.ts, 8, 17)) + +export const store = create(wrap((set) => ({ +>store : Symbol(store, Decl(contextualCheckReentryAfterParameters.ts, 19, 12)) +>create : Symbol(create, Decl(contextualCheckReentryAfterParameters.ts, 13, 73)) +>Store : Symbol(Store, Decl(contextualCheckReentryAfterParameters.ts, 7, 1)) +>wrap : Symbol(wrap, Decl(contextualCheckReentryAfterParameters.ts, 14, 48)) +>set : Symbol(set, Decl(contextualCheckReentryAfterParameters.ts, 19, 41)) + + panel: { surfaces: [] }, +>panel : Symbol(panel, Decl(contextualCheckReentryAfterParameters.ts, 19, 51)) +>surfaces : Symbol(surfaces, Decl(contextualCheckReentryAfterParameters.ts, 20, 12)) + + openFile: (path) => +>openFile : Symbol(openFile, Decl(contextualCheckReentryAfterParameters.ts, 20, 28)) +>path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 21, 15)) + + set((state) => +>set : Symbol(set, Decl(contextualCheckReentryAfterParameters.ts, 19, 41)) +>state : Symbol(state, Decl(contextualCheckReentryAfterParameters.ts, 22, 13)) + + update(state, (current) => { +>update : Symbol(update, Decl(contextualCheckReentryAfterParameters.ts, 17, 5)) +>state : Symbol(state, Decl(contextualCheckReentryAfterParameters.ts, 22, 13)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 23, 27)) + + const existing = current.surfaces.find( +>existing : Symbol(existing, Decl(contextualCheckReentryAfterParameters.ts, 24, 21)) +>current.surfaces.find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>current.surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 23, 27)) +>surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>find : Symbol(Array.find, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) + + (surface): surface is Extract => surface.kind === "file" && surface.path === path, +>surface : Symbol(surface, Decl(contextualCheckReentryAfterParameters.ts, 25, 21)) +>surface : Symbol(surface, Decl(contextualCheckReentryAfterParameters.ts, 25, 21)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>Surface : Symbol(Surface, Decl(contextualCheckReentryAfterParameters.ts, 0, 0)) +>kind : Symbol(kind, Decl(contextualCheckReentryAfterParameters.ts, 25, 60)) +>surface.kind : Symbol(kind, Decl(contextualCheckReentryAfterParameters.ts, 4, 28), Decl(contextualCheckReentryAfterParameters.ts, 4, 73)) +>surface : Symbol(surface, Decl(contextualCheckReentryAfterParameters.ts, 25, 21)) +>kind : Symbol(kind, Decl(contextualCheckReentryAfterParameters.ts, 4, 28), Decl(contextualCheckReentryAfterParameters.ts, 4, 73)) +>surface.path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 4, 42)) +>surface : Symbol(surface, Decl(contextualCheckReentryAfterParameters.ts, 25, 21)) +>path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 4, 42)) +>path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 21, 15)) + + ); + return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; +>existing : Symbol(existing, Decl(contextualCheckReentryAfterParameters.ts, 24, 21)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 23, 27)) +>surfaces : Symbol(surfaces, Decl(contextualCheckReentryAfterParameters.ts, 27, 45)) +>current.surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 23, 27)) +>surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 27, 79)) +>path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 21, 15)) +>kind : Symbol(kind, Decl(contextualCheckReentryAfterParameters.ts, 27, 89)) +>path : Symbol(path, Decl(contextualCheckReentryAfterParameters.ts, 27, 103)) + + }) + ), + close: (id) => +>close : Symbol(close, Decl(contextualCheckReentryAfterParameters.ts, 29, 10)) +>id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 30, 12)) + + set((state) => +>set : Symbol(set, Decl(contextualCheckReentryAfterParameters.ts, 19, 41)) +>state : Symbol(state, Decl(contextualCheckReentryAfterParameters.ts, 31, 13)) + + update(state, (current) => { +>update : Symbol(update, Decl(contextualCheckReentryAfterParameters.ts, 17, 5)) +>state : Symbol(state, Decl(contextualCheckReentryAfterParameters.ts, 31, 13)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 32, 27)) + + const index = current.surfaces.findIndex((entry) => entry.id === id); +>index : Symbol(index, Decl(contextualCheckReentryAfterParameters.ts, 33, 21)) +>current.surfaces.findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --)) +>current.surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 32, 27)) +>surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>findIndex : Symbol(Array.findIndex, Decl(lib.es2015.core.d.ts, --, --)) +>entry : Symbol(entry, Decl(contextualCheckReentryAfterParameters.ts, 33, 58)) +>entry.id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 4, 16), Decl(contextualCheckReentryAfterParameters.ts, 4, 61)) +>entry : Symbol(entry, Decl(contextualCheckReentryAfterParameters.ts, 33, 58)) +>id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 4, 16), Decl(contextualCheckReentryAfterParameters.ts, 4, 61)) +>id : Symbol(id, Decl(contextualCheckReentryAfterParameters.ts, 30, 12)) + + return { surfaces: current.surfaces.slice(index) }; +>surfaces : Symbol(surfaces, Decl(contextualCheckReentryAfterParameters.ts, 34, 24)) +>current.surfaces.slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --)) +>current.surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>current : Symbol(current, Decl(contextualCheckReentryAfterParameters.ts, 32, 27)) +>surfaces : Symbol(Panel.surfaces, Decl(contextualCheckReentryAfterParameters.ts, 5, 17)) +>slice : Symbol(Array.slice, Decl(lib.es5.d.ts, --, --)) +>index : Symbol(index, Decl(contextualCheckReentryAfterParameters.ts, 33, 21)) + + }) + ), +}))); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.types b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.types new file mode 100644 index 0000000000000..0fcb1000bcab9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.types @@ -0,0 +1,190 @@ +//// [tests/cases/compiler/contextualCheckReentryAfterParameters.ts] //// + +=== contextualCheckReentryAfterParameters.ts === +// Instantiating the type predicate inside the nested callback re-enters the +// contextual check of the enclosing functions through their outer type +// parameters. That must not discard the parameter types assigned to them. + +type Surface = { id: string; kind: "file"; path: string } | { id: string; kind: "terminal" }; +>Surface : Surface +>id : string +>kind : "file" +>path : string +>id : string +>kind : "terminal" + +interface Panel { + surfaces: Surface[]; +>surfaces : Surface[] +} +interface Store { + panel: Panel; +>panel : Panel + + openFile: (path: string) => void; +>openFile : (path: string) => void +>path : string + + close: (id: string) => void; +>close : (id: string) => void +>id : string +} +type Creator = (set: (update: (state: T) => Partial) => void) => T; +>Creator : Creator +>set : (update: (state: T) => Partial) => void +>update : (state: T) => Partial +>state : T + +declare function create(init: Creator): T; +>create : (init: Creator) => T +>init : Creator + +declare function wrap(init: Creator): Creator; +>wrap : (init: Creator) => Creator +>init : Creator + +const update = (state: Store, updater: (current: Panel) => Panel): Partial => ({ panel: updater(state.panel) }); +>update : (state: Store, updater: (current: Panel) => Panel) => Partial +>(state: Store, updater: (current: Panel) => Panel): Partial => ({ panel: updater(state.panel) }) : (state: Store, updater: (current: Panel) => Panel) => Partial +>state : Store +>updater : (current: Panel) => Panel +>current : Panel +>({ panel: updater(state.panel) }) : { panel: Panel; } +>{ panel: updater(state.panel) } : { panel: Panel; } +>panel : Panel +>updater(state.panel) : Panel +>updater : (current: Panel) => Panel +>state.panel : Panel +>state : Store +>panel : Panel + +export const store = create(wrap((set) => ({ +>store : Store +>create(wrap((set) => ({ panel: { surfaces: [] }, openFile: (path) => set((state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) ), close: (id) => set((state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) ),}))) : Store +>create : (init: Creator) => T +>wrap((set) => ({ panel: { surfaces: [] }, openFile: (path) => set((state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) ), close: (id) => set((state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) ),})) : Creator +>wrap : (init: Creator) => Creator +>(set) => ({ panel: { surfaces: [] }, openFile: (path) => set((state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) ), close: (id) => set((state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) ),}) : (set: (update: (state: Store) => Partial) => void) => { panel: { surfaces: never[]; }; openFile: (path: string) => void; close: (id: string) => void; } +>set : (update: (state: Store) => Partial) => void +>({ panel: { surfaces: [] }, openFile: (path) => set((state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) ), close: (id) => set((state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) ),}) : { panel: { surfaces: never[]; }; openFile: (path: string) => void; close: (id: string) => void; } +>{ panel: { surfaces: [] }, openFile: (path) => set((state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) ), close: (id) => set((state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) ),} : { panel: { surfaces: never[]; }; openFile: (path: string) => void; close: (id: string) => void; } + + panel: { surfaces: [] }, +>panel : { surfaces: never[]; } +>{ surfaces: [] } : { surfaces: never[]; } +>surfaces : never[] +>[] : never[] + + openFile: (path) => +>openFile : (path: string) => void +>(path) => set((state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) ) : (path: string) => void +>path : string + + set((state) => +>set((state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) ) : void +>set : (update: (state: Store) => Partial) => void +>(state) => update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) : (state: Store) => Partial +>state : Store + + update(state, (current) => { +>update(state, (current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; }) : Partial +>update : (state: Store, updater: (current: Panel) => Panel) => Partial +>state : Store +>(current) => { const existing = current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ); return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; } : (current: Panel) => Panel +>current : Panel + + const existing = current.surfaces.find( +>existing : { id: string; kind: "file"; path: string; } | undefined +>current.surfaces.find( (surface): surface is Extract => surface.kind === "file" && surface.path === path, ) : { id: string; kind: "file"; path: string; } | undefined +>current.surfaces.find : { (predicate: (value: Surface, index: number, obj: Surface[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Surface, index: number, obj: Surface[]) => unknown, thisArg?: any): Surface | undefined; } +>current.surfaces : Surface[] +>current : Panel +>surfaces : Surface[] +>find : { (predicate: (value: Surface, index: number, obj: Surface[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Surface, index: number, obj: Surface[]) => unknown, thisArg?: any): Surface | undefined; } + + (surface): surface is Extract => surface.kind === "file" && surface.path === path, +>(surface): surface is Extract => surface.kind === "file" && surface.path === path : (surface: Surface) => surface is Extract +>surface : Surface +>kind : "file" +>surface.kind === "file" && surface.path === path : boolean +>surface.kind === "file" : boolean +>surface.kind : "file" | "terminal" +>surface : Surface +>kind : "file" | "terminal" +>"file" : "file" +>surface.path === path : boolean +>surface.path : string +>surface : { id: string; kind: "file"; path: string; } +>path : string +>path : string + + ); + return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; +>existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] } : Panel +>existing : { id: string; kind: "file"; path: string; } | undefined +>current : Panel +>{ surfaces: [...current.surfaces, { id: path, kind: "file", path }] } : { surfaces: Surface[]; } +>surfaces : Surface[] +>[...current.surfaces, { id: path, kind: "file", path }] : Surface[] +>...current.surfaces : Surface +>current.surfaces : Surface[] +>current : Panel +>surfaces : Surface[] +>{ id: path, kind: "file", path } : { id: string; kind: "file"; path: string; } +>id : string +>path : string +>kind : "file" +>"file" : "file" +>path : string + + }) + ), + close: (id) => +>close : (id: string) => void +>(id) => set((state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) ) : (id: string) => void +>id : string + + set((state) => +>set((state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) ) : void +>set : (update: (state: Store) => Partial) => void +>(state) => update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) : (state: Store) => Partial +>state : Store + + update(state, (current) => { +>update(state, (current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; }) : Partial +>update : (state: Store, updater: (current: Panel) => Panel) => Partial +>state : Store +>(current) => { const index = current.surfaces.findIndex((entry) => entry.id === id); return { surfaces: current.surfaces.slice(index) }; } : (current: Panel) => { surfaces: Surface[]; } +>current : Panel + + const index = current.surfaces.findIndex((entry) => entry.id === id); +>index : number +>current.surfaces.findIndex((entry) => entry.id === id) : number +>current.surfaces.findIndex : (predicate: (value: Surface, index: number, obj: Surface[]) => unknown, thisArg?: any) => number +>current.surfaces : Surface[] +>current : Panel +>surfaces : Surface[] +>findIndex : (predicate: (value: Surface, index: number, obj: Surface[]) => unknown, thisArg?: any) => number +>(entry) => entry.id === id : (entry: Surface) => boolean +>entry : Surface +>entry.id === id : boolean +>entry.id : string +>entry : Surface +>id : string +>id : string + + return { surfaces: current.surfaces.slice(index) }; +>{ surfaces: current.surfaces.slice(index) } : { surfaces: Surface[]; } +>surfaces : Surface[] +>current.surfaces.slice(index) : Surface[] +>current.surfaces.slice : (start?: number, end?: number) => Surface[] +>current.surfaces : Surface[] +>current : Panel +>surfaces : Surface[] +>slice : (start?: number, end?: number) => Surface[] +>index : number + + }) + ), +}))); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.symbols b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.symbols new file mode 100644 index 0000000000000..88f761461324a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.symbols @@ -0,0 +1,81 @@ +//// [tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts] //// + +=== contextualCheckReentryFromOuterTypeParameters.ts === +interface Argv { +>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0)) +>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 15)) + + command(builder: (args: Argv) => Argv, handler: (args: Arguments) => void): Argv; +>command : Symbol(Argv.command, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 24)) +>U : Symbol(U, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 12)) +>builder : Symbol(builder, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 15)) +>args : Symbol(args, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 25)) +>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0)) +>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 15)) +>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0)) +>U : Symbol(U, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 12)) +>handler : Symbol(handler, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 51)) +>args : Symbol(args, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 62)) +>Arguments : Symbol(Arguments, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 3, 1)) +>U : Symbol(U, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 12)) +>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0)) +>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 15)) + + option(key: K, options: O): Argv<{ [key in K]: O } & Check>; +>option : Symbol(Argv.option, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 100)) +>K : Symbol(K, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 11)) +>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28)) +>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 32)) +>K : Symbol(K, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 11)) +>options : Symbol(options, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 39)) +>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28)) +>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0)) +>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 61)) +>K : Symbol(K, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 11)) +>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28)) +>Check : Symbol(Check, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 78)) +>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28)) +} +type Arguments = { [key in keyof T]: T[key] } & { [key: string]: unknown }; +>Arguments : Symbol(Arguments, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 3, 1)) +>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 15)) +>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 23)) +>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 15)) +>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 15)) +>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 23)) +>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 54)) + +type Check = O extends {} ? {} : {}; +>Check : Symbol(Check, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 78)) +>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 5, 11)) +>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 5, 11)) + +declare const yargs: Argv; +>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 6, 13)) +>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0)) + +yargs.command( +>yargs.command : Symbol(Argv.command, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 24)) +>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 6, 13)) +>command : Symbol(Argv.command, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 24)) + + (yargs) => yargs.option("a", { type: "string" }), +>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 9, 5)) +>yargs.option : Symbol(Argv.option, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 100)) +>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 9, 5)) +>option : Symbol(Argv.option, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 100)) +>type : Symbol(type, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 9, 34)) + + (argv) => { +>argv : Symbol(argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 10, 5)) + + const a: { type: string } = argv.a; +>a : Symbol(a, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 11, 13)) +>type : Symbol(type, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 11, 18)) +>argv.a : Symbol(a) +>argv : Symbol(argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 10, 5)) +>a : Symbol(a) + + }, +); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.types b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.types new file mode 100644 index 0000000000000..bd12f97face3b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.types @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts] //// + +=== contextualCheckReentryFromOuterTypeParameters.ts === +interface Argv { + command(builder: (args: Argv) => Argv, handler: (args: Arguments) => void): Argv; +>command : (builder: (args: Argv) => Argv, handler: (args: Arguments) => void) => Argv +>builder : (args: Argv) => Argv +>args : Argv +>handler : (args: Arguments) => void +>args : Arguments + + option(key: K, options: O): Argv<{ [key in K]: O } & Check>; +>option : (key: K, options: O) => Argv<{ [key in K]: O; } & Check> +>key : K +>options : O +} +type Arguments = { [key in keyof T]: T[key] } & { [key: string]: unknown }; +>Arguments : Arguments +>key : string + +type Check = O extends {} ? {} : {}; +>Check : Check + +declare const yargs: Argv; +>yargs : Argv<{}> + +yargs.command( +>yargs.command( (yargs) => yargs.option("a", { type: "string" }), (argv) => { const a: { type: string } = argv.a; },) : Argv<{}> +>yargs.command : (builder: (args: Argv<{}>) => Argv, handler: (args: Arguments) => void) => Argv<{}> +>yargs : Argv<{}> +>command : (builder: (args: Argv<{}>) => Argv, handler: (args: Arguments) => void) => Argv<{}> + + (yargs) => yargs.option("a", { type: "string" }), +>(yargs) => yargs.option("a", { type: "string" }) : (yargs: Argv<{}>) => Argv<{ a: { type: string; }; }> +>yargs : Argv<{}> +>yargs.option("a", { type: "string" }) : Argv<{ a: { type: string; }; }> +>yargs.option : (key: K, options: O) => Argv<{ [key in K]: O; } & Check> +>yargs : Argv<{}> +>option : (key: K, options: O) => Argv<{ [key in K]: O; } & Check> +>"a" : "a" +>{ type: "string" } : { type: string; } +>type : string +>"string" : "string" + + (argv) => { +>(argv) => { const a: { type: string } = argv.a; } : (argv: Arguments<{ a: { type: string; }; }>) => void +>argv : Arguments<{ a: { type: string; }; }> + + const a: { type: string } = argv.a; +>a : { type: string; } +>type : string +>argv.a : { type: string; } +>argv : Arguments<{ a: { type: string; }; }> +>a : { type: string; } + + }, +); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).symbols new file mode 100644 index 0000000000000..3fe6805b944a0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/contextualOuterTypeParameters.ts] //// + +=== contextualOuterTypeParameters.ts === +// https://github.com/microsoft/TypeScript/issues/59450 + +declare function f(fun: (t: T) => void): void +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 0, 0)) +>fun : Symbol(fun, Decl(contextualOuterTypeParameters.ts, 2, 19)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 2, 25)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 2, 28)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 2, 25)) + +f(t => { +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 0, 0)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 4, 2)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 4, 8)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 4, 2)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 5, 64)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 6, 21)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 4, 2)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 6, 45)) + +}); + +const fn1: (x: T) => void = t => { +>fn1 : Symbol(fn1, Decl(contextualOuterTypeParameters.ts, 9, 5)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 9, 12)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 9, 15)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 9, 12)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 9, 30)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 9, 37)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 9, 30)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 10, 64)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 11, 21)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 9, 30)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 11, 45)) + +}; + +const fn2: (x: T) => void = function test(t) { +>fn2 : Symbol(fn2, Decl(contextualOuterTypeParameters.ts, 14, 5)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 14, 12)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 14, 15)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 14, 12)) +>test : Symbol(test, Decl(contextualOuterTypeParameters.ts, 14, 30)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 14, 45)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 14, 49)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 14, 45)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 15, 64)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 16, 21)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 14, 45)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 16, 45)) + +}; + +const obj: { f: (x: T) => void } = { +>obj : Symbol(obj, Decl(contextualOuterTypeParameters.ts, 19, 5)) +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 19, 12)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 19, 17)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 19, 20)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 19, 17)) + + f(t) { +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 19, 39)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 20, 6)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 20, 10)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 20, 6)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 21, 68)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 22, 25)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 20, 6)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 22, 49)) + } +}; + +f(function self(t) { +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 0, 0)) +>self : Symbol(self, Decl(contextualOuterTypeParameters.ts, 26, 2)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 26, 16)) + + const s = self; +>s : Symbol(s, Decl(contextualOuterTypeParameters.ts, 27, 9)) +>self : Symbol(self, Decl(contextualOuterTypeParameters.ts, 26, 2)) + + type P = Parameters; +>P : Symbol(P, Decl(contextualOuterTypeParameters.ts, 27, 19)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(contextualOuterTypeParameters.ts, 27, 9)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).types new file mode 100644 index 0000000000000..3be38bfec4e31 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).types @@ -0,0 +1,120 @@ +//// [tests/cases/compiler/contextualOuterTypeParameters.ts] //// + +=== contextualOuterTypeParameters.ts === +// https://github.com/microsoft/TypeScript/issues/59450 + +declare function f(fun: (t: T) => void): void +>f : (fun: (t: T) => void) => void +>fun : (t: T) => void +>t : T + +f(t => { +>f(t => { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;}) : void +>f : (fun: (t: T) => void) => void +>t => { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;} : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + +}); + +const fn1: (x: T) => void = t => { +>fn1 : (x: T) => void +>x : T +>t => { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;} : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + +}; + +const fn2: (x: T) => void = function test(t) { +>fn2 : (x: T) => void +>x : T +>function test(t) { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;} : (t: T) => void +>test : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + +}; + +const obj: { f: (x: T) => void } = { +>obj : { f: (x: T) => void; } +>f : (x: T) => void +>x : T +>{ f(t) { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false; }} : { f(t: T): void; } + + f(t) { +>f : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + } +}; + +f(function self(t) { +>f(function self(t) { const s = self; type P = Parameters;}) : void +>f : (fun: (t: T) => void) => void +>function self(t) { const s = self; type P = Parameters;} : (t: T) => void +>self : (t: T) => void +>t : T + + const s = self; +>s : (t: T) => void +>self : (t: T) => void + + type P = Parameters; +>P : [t: unknown] +>s : (t: T) => void + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3fe6805b944a0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/contextualOuterTypeParameters.ts] //// + +=== contextualOuterTypeParameters.ts === +// https://github.com/microsoft/TypeScript/issues/59450 + +declare function f(fun: (t: T) => void): void +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 0, 0)) +>fun : Symbol(fun, Decl(contextualOuterTypeParameters.ts, 2, 19)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 2, 25)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 2, 28)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 2, 25)) + +f(t => { +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 0, 0)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 4, 2)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 4, 8)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 4, 2)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 5, 64)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 6, 21)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 4, 2)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 6, 45)) + +}); + +const fn1: (x: T) => void = t => { +>fn1 : Symbol(fn1, Decl(contextualOuterTypeParameters.ts, 9, 5)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 9, 12)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 9, 15)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 9, 12)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 9, 30)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 9, 37)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 9, 30)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 10, 64)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 11, 21)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 9, 30)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 11, 45)) + +}; + +const fn2: (x: T) => void = function test(t) { +>fn2 : Symbol(fn2, Decl(contextualOuterTypeParameters.ts, 14, 5)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 14, 12)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 14, 15)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 14, 12)) +>test : Symbol(test, Decl(contextualOuterTypeParameters.ts, 14, 30)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 14, 45)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 14, 49)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 14, 45)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 15, 64)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 16, 21)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 14, 45)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 16, 45)) + +}; + +const obj: { f: (x: T) => void } = { +>obj : Symbol(obj, Decl(contextualOuterTypeParameters.ts, 19, 5)) +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 19, 12)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 19, 17)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 19, 20)) +>T : Symbol(T, Decl(contextualOuterTypeParameters.ts, 19, 17)) + + f(t) { +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 19, 39)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 20, 6)) + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : Symbol(isArray, Decl(contextualOuterTypeParameters.ts, 20, 10)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 20, 6)) + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : Symbol(IsObject, Decl(contextualOuterTypeParameters.ts, 21, 68)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 22, 25)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 20, 6)) +>x : Symbol(x, Decl(contextualOuterTypeParameters.ts, 22, 49)) + } +}; + +f(function self(t) { +>f : Symbol(f, Decl(contextualOuterTypeParameters.ts, 0, 0)) +>self : Symbol(self, Decl(contextualOuterTypeParameters.ts, 26, 2)) +>t : Symbol(t, Decl(contextualOuterTypeParameters.ts, 26, 16)) + + const s = self; +>s : Symbol(s, Decl(contextualOuterTypeParameters.ts, 27, 9)) +>self : Symbol(self, Decl(contextualOuterTypeParameters.ts, 26, 2)) + + type P = Parameters; +>P : Symbol(P, Decl(contextualOuterTypeParameters.ts, 27, 19)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(contextualOuterTypeParameters.ts, 27, 9)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types new file mode 100644 index 0000000000000..3be38bfec4e31 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types @@ -0,0 +1,120 @@ +//// [tests/cases/compiler/contextualOuterTypeParameters.ts] //// + +=== contextualOuterTypeParameters.ts === +// https://github.com/microsoft/TypeScript/issues/59450 + +declare function f(fun: (t: T) => void): void +>f : (fun: (t: T) => void) => void +>fun : (t: T) => void +>t : T + +f(t => { +>f(t => { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;}) : void +>f : (fun: (t: T) => void) => void +>t => { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;} : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + +}); + +const fn1: (x: T) => void = t => { +>fn1 : (x: T) => void +>x : T +>t => { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;} : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + +}; + +const fn2: (x: T) => void = function test(t) { +>fn2 : (x: T) => void +>x : T +>function test(t) { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false;} : (t: T) => void +>test : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + +}; + +const obj: { f: (x: T) => void } = { +>obj : { f: (x: T) => void; } +>f : (x: T) => void +>x : T +>{ f(t) { type isArray = (typeof t)[] extends string[] ? true : false; type IsObject = { x: typeof t } extends { x: string } ? true : false; }} : { f(t: T): void; } + + f(t) { +>f : (t: T) => void +>t : T + + type isArray = (typeof t)[] extends string[] ? true : false; +>isArray : T[] extends string[] ? true : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : { x: typeof t; } extends { x: string; } ? true : false +>x : T +>t : T +>x : string +>true : true +>false : false + } +}; + +f(function self(t) { +>f(function self(t) { const s = self; type P = Parameters;}) : void +>f : (fun: (t: T) => void) => void +>function self(t) { const s = self; type P = Parameters;} : (t: T) => void +>self : (t: T) => void +>t : T + + const s = self; +>s : (t: T) => void +>self : (t: T) => void + + type P = Parameters; +>P : [t: unknown] +>s : (t: T) => void + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..a31e69f0899d0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +//// [contextualParameterDefaultReferenceCheckOrder.ts] +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; + + +//// [contextualParameterDefaultReferenceCheckOrder.js] +"use strict"; +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. +const f = (g = () => x, x = 0) => { }; diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..97bc4c3a2eae5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : Symbol(f, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 5)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 10)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 26)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 44)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..86f6c20f91df3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : (g: () => number, x: 1) => void +>g : () => number +>x : 1 +>(g = () => x, x = 0) => {} : (g?: () => number, x?: number) => void +>g : () => number +>() => x : () => number +>x : number +>x : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..a31e69f0899d0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +//// [contextualParameterDefaultReferenceCheckOrder.ts] +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; + + +//// [contextualParameterDefaultReferenceCheckOrder.js] +"use strict"; +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. +const f = (g = () => x, x = 0) => { }; diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..97bc4c3a2eae5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : Symbol(f, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 5)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 10)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 26)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 44)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..86f6c20f91df3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : (g: () => number, x: 1) => void +>g : () => number +>x : 1 +>(g = () => x, x = 0) => {} : (g?: () => number, x?: number) => void +>g : () => number +>() => x : () => number +>x : number +>x : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).symbols new file mode 100644 index 0000000000000..c4969f0ef5812 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>init : Symbol(init, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 27)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) + +interface Store { +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x: boolean) => void; +>a : Symbol(Store.a, Decl(contextualParameterInCircularVariableInitializer.ts, 7, 17)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 8)) + + b: (y: string) => void; +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 9, 8)) +} + +const store = create(() => ({ +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x) => store.b(""), +>a : Symbol(a, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 36)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 8)) +>store.b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) + + b: (y) => {}, +>b : Symbol(b, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 26)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 14, 8)) + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).types new file mode 100644 index 0000000000000..95dd171a5925d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : (init: () => T) => T +>init : () => T + +interface Store { + a: (x: boolean) => void; +>a : (x: boolean) => void +>x : boolean + + b: (y: string) => void; +>b : (y: string) => void +>y : string +} + +const store = create(() => ({ +>store : Store +>create(() => ({ a: (x) => store.b(""), b: (y) => {},})) : Store +>create : (init: () => T) => T +>() => ({ a: (x) => store.b(""), b: (y) => {},}) : () => { a: (x: boolean) => void; b: (y: string) => void; } +>({ a: (x) => store.b(""), b: (y) => {},}) : { a: (x: boolean) => void; b: (y: string) => void; } +>{ a: (x) => store.b(""), b: (y) => {},} : { a: (x: boolean) => void; b: (y: string) => void; } + + a: (x) => store.b(""), +>a : (x: boolean) => void +>(x) => store.b("") : (x: boolean) => void +>x : boolean +>store.b("") : void +>store.b : (y: string) => void +>store : Store +>b : (y: string) => void +>"" : "" + + b: (y) => {}, +>b : (y: string) => void +>(y) => {} : (y: string) => void +>y : string + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c4969f0ef5812 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>init : Symbol(init, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 27)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) + +interface Store { +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x: boolean) => void; +>a : Symbol(Store.a, Decl(contextualParameterInCircularVariableInitializer.ts, 7, 17)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 8)) + + b: (y: string) => void; +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 9, 8)) +} + +const store = create(() => ({ +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x) => store.b(""), +>a : Symbol(a, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 36)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 8)) +>store.b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) + + b: (y) => {}, +>b : Symbol(b, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 26)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 14, 8)) + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).types new file mode 100644 index 0000000000000..95dd171a5925d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : (init: () => T) => T +>init : () => T + +interface Store { + a: (x: boolean) => void; +>a : (x: boolean) => void +>x : boolean + + b: (y: string) => void; +>b : (y: string) => void +>y : string +} + +const store = create(() => ({ +>store : Store +>create(() => ({ a: (x) => store.b(""), b: (y) => {},})) : Store +>create : (init: () => T) => T +>() => ({ a: (x) => store.b(""), b: (y) => {},}) : () => { a: (x: boolean) => void; b: (y: string) => void; } +>({ a: (x) => store.b(""), b: (y) => {},}) : { a: (x: boolean) => void; b: (y: string) => void; } +>{ a: (x) => store.b(""), b: (y) => {},} : { a: (x: boolean) => void; b: (y: string) => void; } + + a: (x) => store.b(""), +>a : (x: boolean) => void +>(x) => store.b("") : (x: boolean) => void +>x : boolean +>store.b("") : void +>store.b : (y: string) => void +>store : Store +>b : (y: string) => void +>"" : "" + + b: (y) => {}, +>b : (y: string) => void +>(y) => {} : (y: string) => void +>y : string + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).symbols new file mode 100644 index 0000000000000..e51b75113df82 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 49)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>options : Symbol(options, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 66)) + + initialState: S; +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 76)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) + + reducers: CR; +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 7, 20)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +}): CR; +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +declare function g(a: T): void; +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 22)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 11)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 23)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 50)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).types new file mode 100644 index 0000000000000..4d0000d7f411b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).types @@ -0,0 +1,43 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>state : S +>options : { initialState: S; reducers: CR; } + + initialState: S; +>initialState : S + + reducers: CR; +>reducers : CR + +}): CR; +declare function g(a: T): void; +>g : (a: T) => void +>a : T + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })) : void +>g : (a: T) => void +>() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : () => { a: (state: number) => number; } +>f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : { a: (state: number) => number; } +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>{ reducers: { a: (state) => state + 1 }, initialState: 0 } : { reducers: { a: (state: number) => number; }; initialState: number; } +>reducers : { a: (state: number) => number; } +>{ a: (state) => state + 1 } : { a: (state: number) => number; } +>a : (state: number) => number +>(state) => state + 1 : (state: number) => number +>state : number +>state + 1 : number +>state : number +>1 : 1 +>initialState : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..e51b75113df82 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 49)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>options : Symbol(options, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 66)) + + initialState: S; +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 76)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) + + reducers: CR; +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 7, 20)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +}): CR; +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +declare function g(a: T): void; +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 22)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 11)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 23)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 50)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).types new file mode 100644 index 0000000000000..4d0000d7f411b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).types @@ -0,0 +1,43 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>state : S +>options : { initialState: S; reducers: CR; } + + initialState: S; +>initialState : S + + reducers: CR; +>reducers : CR + +}): CR; +declare function g(a: T): void; +>g : (a: T) => void +>a : T + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })) : void +>g : (a: T) => void +>() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : () => { a: (state: number) => number; } +>f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : { a: (state: number) => number; } +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>{ reducers: { a: (state) => state + 1 }, initialState: 0 } : { reducers: { a: (state: number) => number; }; initialState: number; } +>reducers : { a: (state: number) => number; } +>{ a: (state) => state + 1 } : { a: (state: number) => number; } +>a : (state: number) => number +>(state) => state + 1 : (state: number) => number +>state : number +>state + 1 : number +>state : number +>1 : 1 +>initialState : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).js new file mode 100644 index 0000000000000..6772baec879f7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).js @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +//// [contextualReturnArrayPatternCallback.ts] +interface Matcher { + matcher(): { match(value: Input): boolean; value?: Value }; +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +declare function array>>(value: Value): Matcher; +declare function when unknown>(callback: Callback): Matcher; +declare function accept>(value: Value): void; + +accept({ + list: array({ + prop: when(value => { + const text: string = value; + return true; + }), + }), +}); + + +//// [contextualReturnArrayPatternCallback.js] +"use strict"; +accept({ + list: array({ + prop: when(value => { + const text = value; + return true; + }), + }), +}); diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).symbols new file mode 100644 index 0000000000000..2e6faa18727fd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).symbols @@ -0,0 +1,89 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +=== contextualReturnArrayPatternCallback.ts === +interface Matcher { +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 0, 18)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 0, 24)) + + matcher(): { match(value: Input): boolean; value?: Value }; +>matcher : Symbol(Matcher.matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 43)) +>match : Symbol(match, Decl(contextualReturnArrayPatternCallback.ts, 1, 16)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 1, 23)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 0, 18)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 1, 46)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 0, 24)) +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Key : Symbol(Key, Decl(contextualReturnArrayPatternCallback.ts, 3, 50)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Key : Symbol(Key, Decl(contextualReturnArrayPatternCallback.ts, 3, 50)) + +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +>ArrayElement : Symbol(ArrayElement, Decl(contextualReturnArrayPatternCallback.ts, 3, 94)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 4, 18)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 4, 18)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 4, 56)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 4, 56)) + +declare function array>>(value: Value): Matcher; +>array : Symbol(array, Decl(contextualReturnArrayPatternCallback.ts, 4, 84)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>ArrayElement : Symbol(ArrayElement, Decl(contextualReturnArrayPatternCallback.ts, 3, 94)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 5, 74)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) + +declare function when unknown>(callback: Callback): Matcher; +>when : Symbol(when, Decl(contextualReturnArrayPatternCallback.ts, 5, 111)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) +>Callback : Symbol(Callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 28)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 6, 47)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) +>callback : Symbol(callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 73)) +>Callback : Symbol(Callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 28)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) + +declare function accept>(value: Value): void; +>accept : Symbol(accept, Decl(contextualReturnArrayPatternCallback.ts, 6, 109)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 7, 24)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>list : Symbol(list, Decl(contextualReturnArrayPatternCallback.ts, 7, 47)) +>prop : Symbol(prop, Decl(contextualReturnArrayPatternCallback.ts, 7, 55)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 7, 77)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 7, 24)) + +accept({ +>accept : Symbol(accept, Decl(contextualReturnArrayPatternCallback.ts, 6, 109)) + + list: array({ +>list : Symbol(list, Decl(contextualReturnArrayPatternCallback.ts, 9, 8)) +>array : Symbol(array, Decl(contextualReturnArrayPatternCallback.ts, 4, 84)) + + prop: when(value => { +>prop : Symbol(prop, Decl(contextualReturnArrayPatternCallback.ts, 10, 17)) +>when : Symbol(when, Decl(contextualReturnArrayPatternCallback.ts, 5, 111)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 11, 19)) + + const text: string = value; +>text : Symbol(text, Decl(contextualReturnArrayPatternCallback.ts, 12, 17)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 11, 19)) + + return true; + }), + }), +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).types new file mode 100644 index 0000000000000..8ae0e4c69acc3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).types @@ -0,0 +1,60 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +=== contextualReturnArrayPatternCallback.ts === +interface Matcher { + matcher(): { match(value: Input): boolean; value?: Value }; +>matcher : () => { match(value: Input): boolean; value?: Value; } +>match : (value: Input) => boolean +>value : Input +>value : Value | undefined +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +>Pattern : Pattern + +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +>ArrayElement : ArrayElement + +declare function array>>(value: Value): Matcher; +>array : >>(value: Value) => Matcher +>value : Value + +declare function when unknown>(callback: Callback): Matcher; +>when : unknown>(callback: Callback) => Matcher +>value : Input +>callback : Callback + +declare function accept>(value: Value): void; +>accept : >(value: Value) => void +>list : { prop: string; }[] +>prop : string +>value : Value + +accept({ +>accept({ list: array({ prop: when(value => { const text: string = value; return true; }), }),}) : void +>accept : >(value: Value) => void +>{ list: array({ prop: when(value => { const text: string = value; return true; }), }),} : { list: Matcher<{ prop: string; }[], { prop: Matcher; }>; } + + list: array({ +>list : Matcher<{ prop: string; }[], { prop: Matcher; }> +>array({ prop: when(value => { const text: string = value; return true; }), }) : Matcher<{ prop: string; }[], { prop: Matcher; }> +>array : >>(value: Value) => Matcher +>{ prop: when(value => { const text: string = value; return true; }), } : { prop: Matcher; } + + prop: when(value => { +>prop : Matcher +>when(value => { const text: string = value; return true; }) : Matcher +>when : unknown>(callback: Callback) => Matcher +>value => { const text: string = value; return true; } : (value: string) => boolean +>value : string + + const text: string = value; +>text : string +>value : string + + return true; +>true : true + + }), + }), +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).js new file mode 100644 index 0000000000000..6772baec879f7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).js @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +//// [contextualReturnArrayPatternCallback.ts] +interface Matcher { + matcher(): { match(value: Input): boolean; value?: Value }; +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +declare function array>>(value: Value): Matcher; +declare function when unknown>(callback: Callback): Matcher; +declare function accept>(value: Value): void; + +accept({ + list: array({ + prop: when(value => { + const text: string = value; + return true; + }), + }), +}); + + +//// [contextualReturnArrayPatternCallback.js] +"use strict"; +accept({ + list: array({ + prop: when(value => { + const text = value; + return true; + }), + }), +}); diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..2e6faa18727fd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).symbols @@ -0,0 +1,89 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +=== contextualReturnArrayPatternCallback.ts === +interface Matcher { +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 0, 18)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 0, 24)) + + matcher(): { match(value: Input): boolean; value?: Value }; +>matcher : Symbol(Matcher.matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 43)) +>match : Symbol(match, Decl(contextualReturnArrayPatternCallback.ts, 1, 16)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 1, 23)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 0, 18)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 1, 46)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 0, 24)) +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Key : Symbol(Key, Decl(contextualReturnArrayPatternCallback.ts, 3, 50)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Key : Symbol(Key, Decl(contextualReturnArrayPatternCallback.ts, 3, 50)) + +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +>ArrayElement : Symbol(ArrayElement, Decl(contextualReturnArrayPatternCallback.ts, 3, 94)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 4, 18)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 4, 18)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 4, 56)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 4, 56)) + +declare function array>>(value: Value): Matcher; +>array : Symbol(array, Decl(contextualReturnArrayPatternCallback.ts, 4, 84)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>ArrayElement : Symbol(ArrayElement, Decl(contextualReturnArrayPatternCallback.ts, 3, 94)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 5, 74)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) + +declare function when unknown>(callback: Callback): Matcher; +>when : Symbol(when, Decl(contextualReturnArrayPatternCallback.ts, 5, 111)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) +>Callback : Symbol(Callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 28)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 6, 47)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) +>callback : Symbol(callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 73)) +>Callback : Symbol(Callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 28)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) + +declare function accept>(value: Value): void; +>accept : Symbol(accept, Decl(contextualReturnArrayPatternCallback.ts, 6, 109)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 7, 24)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>list : Symbol(list, Decl(contextualReturnArrayPatternCallback.ts, 7, 47)) +>prop : Symbol(prop, Decl(contextualReturnArrayPatternCallback.ts, 7, 55)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 7, 77)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 7, 24)) + +accept({ +>accept : Symbol(accept, Decl(contextualReturnArrayPatternCallback.ts, 6, 109)) + + list: array({ +>list : Symbol(list, Decl(contextualReturnArrayPatternCallback.ts, 9, 8)) +>array : Symbol(array, Decl(contextualReturnArrayPatternCallback.ts, 4, 84)) + + prop: when(value => { +>prop : Symbol(prop, Decl(contextualReturnArrayPatternCallback.ts, 10, 17)) +>when : Symbol(when, Decl(contextualReturnArrayPatternCallback.ts, 5, 111)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 11, 19)) + + const text: string = value; +>text : Symbol(text, Decl(contextualReturnArrayPatternCallback.ts, 12, 17)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 11, 19)) + + return true; + }), + }), +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types new file mode 100644 index 0000000000000..8ae0e4c69acc3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types @@ -0,0 +1,60 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +=== contextualReturnArrayPatternCallback.ts === +interface Matcher { + matcher(): { match(value: Input): boolean; value?: Value }; +>matcher : () => { match(value: Input): boolean; value?: Value; } +>match : (value: Input) => boolean +>value : Input +>value : Value | undefined +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +>Pattern : Pattern + +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +>ArrayElement : ArrayElement + +declare function array>>(value: Value): Matcher; +>array : >>(value: Value) => Matcher +>value : Value + +declare function when unknown>(callback: Callback): Matcher; +>when : unknown>(callback: Callback) => Matcher +>value : Input +>callback : Callback + +declare function accept>(value: Value): void; +>accept : >(value: Value) => void +>list : { prop: string; }[] +>prop : string +>value : Value + +accept({ +>accept({ list: array({ prop: when(value => { const text: string = value; return true; }), }),}) : void +>accept : >(value: Value) => void +>{ list: array({ prop: when(value => { const text: string = value; return true; }), }),} : { list: Matcher<{ prop: string; }[], { prop: Matcher; }>; } + + list: array({ +>list : Matcher<{ prop: string; }[], { prop: Matcher; }> +>array({ prop: when(value => { const text: string = value; return true; }), }) : Matcher<{ prop: string; }[], { prop: Matcher; }> +>array : >>(value: Value) => Matcher +>{ prop: when(value => { const text: string = value; return true; }), } : { prop: Matcher; } + + prop: when(value => { +>prop : Matcher +>when(value => { const text: string = value; return true; }) : Matcher +>when : unknown>(callback: Callback) => Matcher +>value => { const text: string = value; return true; } : (value: string) => boolean +>value : string + + const text: string = value; +>text : string +>value : string + + return true; +>true : true + + }), + }), +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.js b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.js new file mode 100644 index 0000000000000..ca1d3b91449da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.js @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts] //// + +//// [contextualReturnTypeInSpreadArgument.ts] +enum Kind { A, B } + +interface ItemA { kind: Kind.A; name: string } +interface ItemB { kind: Kind.B; size: number } +type Item = ItemA | ItemB; + +declare function create(options: { items?: () => readonly Item[]; label: string }): void; + +function test(flag: boolean) { + create({ + label: "x", + ...(flag ? {} : { + items: () => [{ kind: Kind.A, name: "a" }], + }), + }); +} + + +//// [contextualReturnTypeInSpreadArgument.js] +"use strict"; +var Kind; +(function (Kind) { + Kind[Kind["A"] = 0] = "A"; + Kind[Kind["B"] = 1] = "B"; +})(Kind || (Kind = {})); +function test(flag) { + create({ + label: "x", + ...(flag ? {} : { + items: () => [{ kind: Kind.A, name: "a" }], + }), + }); +} diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.symbols b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.symbols new file mode 100644 index 0000000000000..0802a21d1a19b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.symbols @@ -0,0 +1,59 @@ +//// [tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts] //// + +=== contextualReturnTypeInSpreadArgument.ts === +enum Kind { A, B } +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>B : Symbol(Kind.B, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 14)) + +interface ItemA { kind: Kind.A; name: string } +>ItemA : Symbol(ItemA, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 18)) +>kind : Symbol(ItemA.kind, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 17)) +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>name : Symbol(ItemA.name, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 31)) + +interface ItemB { kind: Kind.B; size: number } +>ItemB : Symbol(ItemB, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 46)) +>kind : Symbol(ItemB.kind, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 17)) +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>B : Symbol(Kind.B, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 14)) +>size : Symbol(ItemB.size, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 31)) + +type Item = ItemA | ItemB; +>Item : Symbol(Item, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 46)) +>ItemA : Symbol(ItemA, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 18)) +>ItemB : Symbol(ItemB, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 46)) + +declare function create(options: { items?: () => readonly Item[]; label: string }): void; +>create : Symbol(create, Decl(contextualReturnTypeInSpreadArgument.ts, 4, 26)) +>options : Symbol(options, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 24)) +>items : Symbol(items, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 34)) +>Item : Symbol(Item, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 46)) +>label : Symbol(label, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 65)) + +function test(flag: boolean) { +>test : Symbol(test, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 89)) +>flag : Symbol(flag, Decl(contextualReturnTypeInSpreadArgument.ts, 8, 14)) + + create({ +>create : Symbol(create, Decl(contextualReturnTypeInSpreadArgument.ts, 4, 26)) + + label: "x", +>label : Symbol(label, Decl(contextualReturnTypeInSpreadArgument.ts, 9, 12)) + + ...(flag ? {} : { +>flag : Symbol(flag, Decl(contextualReturnTypeInSpreadArgument.ts, 8, 14)) + + items: () => [{ kind: Kind.A, name: "a" }], +>items : Symbol(items, Decl(contextualReturnTypeInSpreadArgument.ts, 11, 25)) +>kind : Symbol(kind, Decl(contextualReturnTypeInSpreadArgument.ts, 12, 27)) +>Kind.A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>name : Symbol(name, Decl(contextualReturnTypeInSpreadArgument.ts, 12, 41)) + + }), + }); +} + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.types b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.types new file mode 100644 index 0000000000000..6c1780590bad8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.types @@ -0,0 +1,63 @@ +//// [tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts] //// + +=== contextualReturnTypeInSpreadArgument.ts === +enum Kind { A, B } +>Kind : Kind +>A : Kind.A +>B : Kind.B + +interface ItemA { kind: Kind.A; name: string } +>kind : Kind.A +>Kind : any +>name : string + +interface ItemB { kind: Kind.B; size: number } +>kind : Kind.B +>Kind : any +>size : number + +type Item = ItemA | ItemB; +>Item : Item + +declare function create(options: { items?: () => readonly Item[]; label: string }): void; +>create : (options: { items?: () => readonly Item[]; label: string; }) => void +>options : { items?: () => readonly Item[]; label: string; } +>items : (() => readonly Item[]) | undefined +>label : string + +function test(flag: boolean) { +>test : (flag: boolean) => void +>flag : boolean + + create({ +>create({ label: "x", ...(flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], }), }) : void +>create : (options: { items?: () => readonly Item[]; label: string; }) => void +>{ label: "x", ...(flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], }), } : { label: string; items?: (() => { kind: Kind.A; name: string; }[]) | undefined; } + + label: "x", +>label : string +>"x" : "x" + + ...(flag ? {} : { +>(flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], }) : {} | { items: () => { kind: Kind.A; name: string; }[]; } +>flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], } : {} | { items: () => { kind: Kind.A; name: string; }[]; } +>flag : boolean +>{} : {} +>{ items: () => [{ kind: Kind.A, name: "a" }], } : { items: () => { kind: Kind.A; name: string; }[]; } + + items: () => [{ kind: Kind.A, name: "a" }], +>items : () => { kind: Kind.A; name: string; }[] +>() => [{ kind: Kind.A, name: "a" }] : () => { kind: Kind.A; name: string; }[] +>[{ kind: Kind.A, name: "a" }] : { kind: Kind.A; name: string; }[] +>{ kind: Kind.A, name: "a" } : { kind: Kind.A; name: string; } +>kind : Kind.A +>Kind.A : Kind.A +>Kind : typeof Kind +>A : Kind.A +>name : string +>"a" : "a" + + }), + }); +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..8b4161c226ae7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +//// [cycleYieldThroughVarianceCheckOrder.ts] +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { + p: E["p"]; +} +declare class E extends mix(Base) { + p: number; +} +declare function mix object>(x: T): T; +declare class Base { + constructor(arg?: InstanceType); +} + + +//// [cycleYieldThroughVarianceCheckOrder.js] +"use strict"; +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..38e787a55de34 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).symbols @@ -0,0 +1,39 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 16)) + + p: E["p"]; +>p : Symbol(B.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 20)) +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +} +declare class E extends mix(Base) { +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + p: number; +>p : Symbol(E.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 7, 35)) +} +declare function mix object>(x: T): T; +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>x : Symbol(x, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 49)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) + +declare class Base { +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + constructor(arg?: InstanceType); +>arg : Symbol(arg, Decl(cycleYieldThroughVarianceCheckOrder.ts, 12, 16)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..7c73b8e4d56be --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).types @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : B + + p: E["p"]; +>p : number +} +declare class E extends mix(Base) { +>E : E +>mix(Base) : Base +>mix : object>(x: T) => T +>Base : typeof Base + + p: number; +>p : number +} +declare function mix object>(x: T): T; +>mix : object>(x: T) => T +>x : T + +declare class Base { +>Base : Base + + constructor(arg?: InstanceType); +>arg : B | undefined +>B : typeof B +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..8b4161c226ae7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +//// [cycleYieldThroughVarianceCheckOrder.ts] +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { + p: E["p"]; +} +declare class E extends mix(Base) { + p: number; +} +declare function mix object>(x: T): T; +declare class Base { + constructor(arg?: InstanceType); +} + + +//// [cycleYieldThroughVarianceCheckOrder.js] +"use strict"; +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..38e787a55de34 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,39 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 16)) + + p: E["p"]; +>p : Symbol(B.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 20)) +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +} +declare class E extends mix(Base) { +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + p: number; +>p : Symbol(E.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 7, 35)) +} +declare function mix object>(x: T): T; +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>x : Symbol(x, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 49)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) + +declare class Base { +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + constructor(arg?: InstanceType); +>arg : Symbol(arg, Decl(cycleYieldThroughVarianceCheckOrder.ts, 12, 16)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..7c73b8e4d56be --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : B + + p: E["p"]; +>p : number +} +declare class E extends mix(Base) { +>E : E +>mix(Base) : Base +>mix : object>(x: T) => T +>Base : typeof Base + + p: number; +>p : number +} +declare function mix object>(x: T): T; +>mix : object>(x: T) => T +>x : T + +declare class Base { +>Base : Base + + constructor(arg?: InstanceType); +>arg : B | undefined +>B : typeof B +} + diff --git a/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.js b/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.js index 935e9baeed1ad..c43a610ffef9d 100644 --- a/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.js +++ b/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.js @@ -77,5 +77,7 @@ export declare const obsA: { v: 0; }; export declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; diff --git a/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.types b/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.types index f7cb243d2a23e..ed5fe02f28302 100644 --- a/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.types +++ b/tsc/testdata/baselines/reference/compiler/declarationEmitExternalModuleContainerIndexDeclarationOrder.types @@ -26,8 +26,8 @@ export const obsA = expand(); >expand : () => { [K in keyof X]: X[K]; } export const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } === /ambient.d.ts === diff --git a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt index 1826289e03769..8dcbaf204205d 100644 --- a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt @@ -1,17 +1,8 @@ -declarationEmitUnknownImport.ts(1,1): error TS2303: Circular definition of import alias 'Foo'. -declarationEmitUnknownImport.ts(1,14): error TS2304: Cannot find name 'SomeNonExistingName'. declarationEmitUnknownImport.ts(1,14): error TS2503: Cannot find namespace 'SomeNonExistingName'. -declarationEmitUnknownImport.ts(2,9): error TS2303: Circular definition of import alias 'Foo'. -==== declarationEmitUnknownImport.ts (4 errors) ==== +==== declarationEmitUnknownImport.ts (1 errors) ==== import Foo = SomeNonExistingName - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2303: Circular definition of import alias 'Foo'. - ~~~~~~~~~~~~~~~~~~~ -!!! error TS2304: Cannot find name 'SomeNonExistingName'. ~~~~~~~~~~~~~~~~~~~ !!! error TS2503: Cannot find namespace 'SomeNonExistingName'. - export {Foo} - ~~~ -!!! error TS2303: Circular definition of import alias 'Foo'. \ No newline at end of file + export {Foo} \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt index f52b6fd9af9fc..db5cb25071de4 100644 --- a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt @@ -1,23 +1,14 @@ -declarationEmitUnknownImport2.ts(1,1): error TS2303: Circular definition of import alias 'Foo'. declarationEmitUnknownImport2.ts(1,12): error TS1005: '=' expected. -declarationEmitUnknownImport2.ts(1,12): error TS2304: Cannot find name 'From'. declarationEmitUnknownImport2.ts(1,12): error TS2503: Cannot find namespace 'From'. declarationEmitUnknownImport2.ts(1,17): error TS1005: ';' expected. -declarationEmitUnknownImport2.ts(2,1): error TS2303: Circular definition of import alias 'Foo'. -==== declarationEmitUnknownImport2.ts (6 errors) ==== +==== declarationEmitUnknownImport2.ts (3 errors) ==== import Foo From './Foo'; // Syntax error - ~~~~~~~~~~~~~~~ -!!! error TS2303: Circular definition of import alias 'Foo'. ~~~~ !!! error TS1005: '=' expected. ~~~~ -!!! error TS2304: Cannot find name 'From'. - ~~~~ !!! error TS2503: Cannot find namespace 'From'. ~~~~~~~ !!! error TS1005: ';' expected. - export default Foo - ~~~~~~~~~~~~~~~~~~ -!!! error TS2303: Circular definition of import alias 'Foo'. \ No newline at end of file + export default Foo \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt new file mode 100644 index 0000000000000..88bdce38b167c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt @@ -0,0 +1,24 @@ +deferredTypeReferenceCycleRollback.ts(17,31): error TS2304: Cannot find name 'Missing'. + + +==== deferredTypeReferenceCycleRollback.ts (1 errors) ==== + // A cycle rollback used to reset the type of the Array> + // node while the deferred reference identified by that node survived, + // which crashed a later instantiation of it. + + declare function declare(): void; + + interface PluginObj { + visitor: Visit; + } + type Visit = VisitFn | VisitObj; + type VisitFn = (path: NodePath

) => void; + interface VisitObj {} + declare class NodePath { + parentPath: NodePath>; + get: Get; + } + type Get = T extends Array ? Array> : never; + ~~~~~~~ +!!! error TS2304: Cannot find name 'Missing'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.symbols b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.symbols new file mode 100644 index 0000000000000..285889376a2ba --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.symbols @@ -0,0 +1,70 @@ +//// [tests/cases/compiler/deferredTypeReferenceCycleRollback.ts] //// + +=== deferredTypeReferenceCycleRollback.ts === +// A cycle rollback used to reset the type of the Array> +// node while the deferred reference identified by that node survived, +// which crashed a later instantiation of it. + +declare function declare(): void; +>declare : Symbol(declare, Decl(deferredTypeReferenceCycleRollback.ts, 0, 0)) +>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 4, 25)) +>PluginObj : Symbol(PluginObj, Decl(deferredTypeReferenceCycleRollback.ts, 4, 66)) +>PluginObj : Symbol(PluginObj, Decl(deferredTypeReferenceCycleRollback.ts, 4, 66)) + +interface PluginObj { +>PluginObj : Symbol(PluginObj, Decl(deferredTypeReferenceCycleRollback.ts, 4, 66)) +>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 6, 20)) + + visitor: Visit; +>visitor : Symbol(PluginObj.visitor, Decl(deferredTypeReferenceCycleRollback.ts, 6, 34)) +>Visit : Symbol(Visit, Decl(deferredTypeReferenceCycleRollback.ts, 8, 1)) +>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 6, 20)) +} +type Visit = VisitFn | VisitObj; +>Visit : Symbol(Visit, Decl(deferredTypeReferenceCycleRollback.ts, 8, 1)) +>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 9, 11)) +>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 9, 13)) +>VisitFn : Symbol(VisitFn, Decl(deferredTypeReferenceCycleRollback.ts, 9, 50)) +>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 9, 11)) +>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 9, 13)) +>VisitObj : Symbol(VisitObj, Decl(deferredTypeReferenceCycleRollback.ts, 10, 49)) +>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 9, 11)) +>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 9, 13)) + +type VisitFn = (path: NodePath

) => void; +>VisitFn : Symbol(VisitFn, Decl(deferredTypeReferenceCycleRollback.ts, 9, 50)) +>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 10, 13)) +>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 10, 15)) +>path : Symbol(path, Decl(deferredTypeReferenceCycleRollback.ts, 10, 22)) +>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27)) +>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 10, 15)) + +interface VisitObj {} +>VisitObj : Symbol(VisitObj, Decl(deferredTypeReferenceCycleRollback.ts, 10, 49)) +>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 11, 19)) +>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 11, 21)) + +declare class NodePath { +>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27)) +>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 12, 23)) + + parentPath: NodePath>; +>parentPath : Symbol(NodePath.parentPath, Decl(deferredTypeReferenceCycleRollback.ts, 12, 27)) +>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27)) +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 12, 23)) + + get: Get; +>get : Symbol(NodePath.get, Decl(deferredTypeReferenceCycleRollback.ts, 13, 43)) +>Get : Symbol(Get, Decl(deferredTypeReferenceCycleRollback.ts, 15, 1)) +>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 12, 23)) +} +type Get = T extends Array ? Array> : never; +>Get : Symbol(Get, Decl(deferredTypeReferenceCycleRollback.ts, 15, 1)) +>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 16, 9)) +>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 16, 9)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Missing : Symbol(Missing) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.types b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.types new file mode 100644 index 0000000000000..7db259991a1ca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.types @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/deferredTypeReferenceCycleRollback.ts] //// + +=== deferredTypeReferenceCycleRollback.ts === +// A cycle rollback used to reset the type of the Array> +// node while the deferred reference identified by that node survived, +// which crashed a later instantiation of it. + +declare function declare(): void; +>declare : >() => void + +interface PluginObj { + visitor: Visit; +>visitor : Visit +} +type Visit = VisitFn | VisitObj; +>Visit : Visit + +type VisitFn = (path: NodePath

) => void; +>VisitFn : VisitFn +>path : NodePath

= P extends `${infer Head}.${infer Tail}` ? [Head, Tail] : [P]; +>Split : Symbol(Split, Decl(substitutionInDeferredConditionalOfConditional.ts, 16, 16)) +>P : Symbol(P, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 11)) +>P : Symbol(P, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 11)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 49)) +>Tail : Symbol(Tail, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 63)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 49)) +>Tail : Symbol(Tail, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 63)) +>P : Symbol(P, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 11)) + +type Children = S["states"] extends Record ? S["states"] : Record; +>Children : Symbol(Children, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 92)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 18, 14)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 18, 14)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 18, 14)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) + +type NeedsRecord> = T; +>NeedsRecord : Symbol(NeedsRecord, Decl(substitutionInDeferredConditionalOfConditional.ts, 18, 116)) +>T : Symbol(T, Decl(substitutionInDeferredConditionalOfConditional.ts, 19, 17)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +>T : Symbol(T, Decl(substitutionInDeferredConditionalOfConditional.ts, 19, 17)) + +type ChildrenAt, P extends string> = NeedsRecord>>>; +>ChildrenAt : Symbol(ChildrenAt, Decl(substitutionInDeferredConditionalOfConditional.ts, 19, 55)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 20, 16)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +>P : Symbol(P, Decl(substitutionInDeferredConditionalOfConditional.ts, 20, 49)) +>NeedsRecord : Symbol(NeedsRecord, Decl(substitutionInDeferredConditionalOfConditional.ts, 18, 116)) +>Children : Symbol(Children, Decl(substitutionInDeferredConditionalOfConditional.ts, 17, 92)) +>Resolve : Symbol(Resolve, Decl(substitutionInDeferredConditionalOfConditional.ts, 6, 1)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 20, 16)) +>Split : Symbol(Split, Decl(substitutionInDeferredConditionalOfConditional.ts, 16, 16)) +>P : Symbol(P, Decl(substitutionInDeferredConditionalOfConditional.ts, 20, 49)) + diff --git a/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.types b/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.types new file mode 100644 index 0000000000000..73ed28bdbf7d5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.types @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/substitutionInDeferredConditionalOfConditional.ts] //// + +=== substitutionInDeferredConditionalOfConditional.ts === +// Children always produces a Record, so it satisfies NeedsRecord. Its +// true branch narrows S["states"] to Record even when S is +// a conditional type that is itself deferred. + +interface Schema { + states?: Record; +>states : Record | undefined +} +type Resolve, Segments extends readonly string[]> = +>Resolve : Resolve + + Segments extends [infer Head extends string, ...infer Rest extends string[]] + ? Head extends keyof S + ? Rest extends [] + ? S[Head] + : S[Head]["states"] extends Record + ? Resolve + : never + : never + : never; +type Split

= P extends `${infer Head}.${infer Tail}` ? [Head, Tail] : [P]; +>Split : Split

+ +type Children = S["states"] extends Record ? S["states"] : Record; +>Children : Children + +type NeedsRecord> = T; +>NeedsRecord : T + +type ChildrenAt, P extends string> = NeedsRecord>>>; +>ChildrenAt : Children>> + diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt new file mode 100644 index 0000000000000..afb511fd91c39 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt @@ -0,0 +1,81 @@ +templateLiteralTypeExcessiveLength.ts(14,16): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(15,6): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(15,11): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(15,28): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(19,21): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(20,6): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(20,11): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(20,31): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(33,24): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(34,6): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(34,11): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(34,38): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== templateLiteralTypeExcessiveLength.ts (12 errors) ==== + // Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and + // keeps tail-recursing forever. The checker must report an error instead of building an unbounded + // template literal type. + + type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + + type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + + // The string literal doubles on every iteration. + type Explode = { + ~ + [P in Recur<5, "a"> as `${P}_key`]: any; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + }; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // The number of placeholders doubles on every iteration. + type ExplodeSpans = { + ~ + [P in Recur<5, string> as `${P}_key`]: any; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + }; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // Every text segment stays small, but the number of segments doubles on every iteration, + // so the combined text length grows without bound. + type A16 = "aaaaaaaaaaaaaaaa"; + type A64 = `${A16}${A16}${A16}${A16}`; + type A256 = `${A64}${A64}${A64}${A64}`; + type A1024 = `${A256}${A256}${A256}${A256}`; + + type RecurSegments = + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + + type ExplodeSegments = { + ~ + [P in RecurSegments<5, A1024> as `${P}_key`]: any; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + }; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).js new file mode 100644 index 0000000000000..36fa92d4a5035 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).js @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +//// [templateLiteralTypeExcessiveLength.ts] +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + +type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +// The string literal doubles on every iteration. +type Explode = { + [P in Recur<5, "a"> as `${P}_key`]: any; +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { + [P in Recur<5, string> as `${P}_key`]: any; +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +type A64 = `${A16}${A16}${A16}${A16}`; +type A256 = `${A64}${A64}${A64}${A64}`; +type A1024 = `${A256}${A256}${A256}${A256}`; + +type RecurSegments = + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + +type ExplodeSegments = { + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +}; + + +//// [templateLiteralTypeExcessiveLength.js] +"use strict"; +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).symbols new file mode 100644 index 0000000000000..2e85049b74921 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).symbols @@ -0,0 +1,109 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +=== templateLiteralTypeExcessiveLength.ts === +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 2 ? any : +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 1 ? 0 : 0; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + +type Recur = +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) + + N extends 0 ? S : Recur, `${S}_${S}`>; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) + +// The string literal doubles on every iteration. +type Explode = { +>Explode : Symbol(Explode, Decl(templateLiteralTypeExcessiveLength.ts, 10, 49)) + + [P in Recur<5, "a"> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 14, 5)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 14, 5)) + +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { +>ExplodeSpans : Symbol(ExplodeSpans, Decl(templateLiteralTypeExcessiveLength.ts, 15, 2)) + + [P in Recur<5, string> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 19, 5)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 19, 5)) + +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) + +type A64 = `${A16}${A16}${A16}${A16}`; +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) + +type A256 = `${A64}${A64}${A64}${A64}`; +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) + +type A1024 = `${A256}${A256}${A256}${A256}`; +>A1024 : Symbol(A1024, Decl(templateLiteralTypeExcessiveLength.ts, 26, 39)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) + +type RecurSegments = +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) + + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) + +type ExplodeSegments = { +>ExplodeSegments : Symbol(ExplodeSegments, Decl(templateLiteralTypeExcessiveLength.ts, 30, 65)) + + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 33, 5)) +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>A1024 : Symbol(A1024, Decl(templateLiteralTypeExcessiveLength.ts, 26, 39)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 33, 5)) + +}; + diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).types new file mode 100644 index 0000000000000..e882332afbf78 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).types @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +=== templateLiteralTypeExcessiveLength.ts === +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = +>Dec : Dec + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + +type Recur = +>Recur : Recur + + N extends 0 ? S : Recur, `${S}_${S}`>; + +// The string literal doubles on every iteration. +type Explode = { +>Explode : Explode + + [P in Recur<5, "a"> as `${P}_key`]: any; +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { +>ExplodeSpans : ExplodeSpans + + [P in Recur<5, string> as `${P}_key`]: any; +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +>A16 : "aaaaaaaaaaaaaaaa" + +type A64 = `${A16}${A16}${A16}${A16}`; +>A64 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type A256 = `${A64}${A64}${A64}${A64}`; +>A256 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type A1024 = `${A256}${A256}${A256}${A256}`; +>A1024 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type RecurSegments = +>RecurSegments : RecurSegments + + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + +type ExplodeSegments = { +>ExplodeSegments : ExplodeSegments + + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +}; + diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..afb511fd91c39 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt @@ -0,0 +1,81 @@ +templateLiteralTypeExcessiveLength.ts(14,16): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(15,6): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(15,11): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(15,28): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(19,21): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(20,6): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(20,11): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(20,31): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(33,24): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(34,6): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(34,11): error TS2589: Type instantiation is excessively deep and possibly infinite. +templateLiteralTypeExcessiveLength.ts(34,38): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== templateLiteralTypeExcessiveLength.ts (12 errors) ==== + // Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and + // keeps tail-recursing forever. The checker must report an error instead of building an unbounded + // template literal type. + + type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + + type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + + // The string literal doubles on every iteration. + type Explode = { + ~ + [P in Recur<5, "a"> as `${P}_key`]: any; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + }; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // The number of placeholders doubles on every iteration. + type ExplodeSpans = { + ~ + [P in Recur<5, string> as `${P}_key`]: any; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + }; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // Every text segment stays small, but the number of segments doubles on every iteration, + // so the combined text length grows without bound. + type A16 = "aaaaaaaaaaaaaaaa"; + type A64 = `${A16}${A16}${A16}${A16}`; + type A256 = `${A64}${A64}${A64}${A64}`; + type A1024 = `${A256}${A256}${A256}${A256}`; + + type RecurSegments = + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + + type ExplodeSegments = { + ~ + [P in RecurSegments<5, A1024> as `${P}_key`]: any; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + }; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).js new file mode 100644 index 0000000000000..36fa92d4a5035 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).js @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +//// [templateLiteralTypeExcessiveLength.ts] +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + +type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +// The string literal doubles on every iteration. +type Explode = { + [P in Recur<5, "a"> as `${P}_key`]: any; +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { + [P in Recur<5, string> as `${P}_key`]: any; +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +type A64 = `${A16}${A16}${A16}${A16}`; +type A256 = `${A64}${A64}${A64}${A64}`; +type A1024 = `${A256}${A256}${A256}${A256}`; + +type RecurSegments = + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + +type ExplodeSegments = { + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +}; + + +//// [templateLiteralTypeExcessiveLength.js] +"use strict"; +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..2e85049b74921 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).symbols @@ -0,0 +1,109 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +=== templateLiteralTypeExcessiveLength.ts === +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 2 ? any : +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 1 ? 0 : 0; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + +type Recur = +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) + + N extends 0 ? S : Recur, `${S}_${S}`>; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) + +// The string literal doubles on every iteration. +type Explode = { +>Explode : Symbol(Explode, Decl(templateLiteralTypeExcessiveLength.ts, 10, 49)) + + [P in Recur<5, "a"> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 14, 5)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 14, 5)) + +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { +>ExplodeSpans : Symbol(ExplodeSpans, Decl(templateLiteralTypeExcessiveLength.ts, 15, 2)) + + [P in Recur<5, string> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 19, 5)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 19, 5)) + +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) + +type A64 = `${A16}${A16}${A16}${A16}`; +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) + +type A256 = `${A64}${A64}${A64}${A64}`; +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) + +type A1024 = `${A256}${A256}${A256}${A256}`; +>A1024 : Symbol(A1024, Decl(templateLiteralTypeExcessiveLength.ts, 26, 39)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) + +type RecurSegments = +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) + + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) + +type ExplodeSegments = { +>ExplodeSegments : Symbol(ExplodeSegments, Decl(templateLiteralTypeExcessiveLength.ts, 30, 65)) + + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 33, 5)) +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>A1024 : Symbol(A1024, Decl(templateLiteralTypeExcessiveLength.ts, 26, 39)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 33, 5)) + +}; + diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).types new file mode 100644 index 0000000000000..e882332afbf78 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).types @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +=== templateLiteralTypeExcessiveLength.ts === +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = +>Dec : Dec + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + +type Recur = +>Recur : Recur + + N extends 0 ? S : Recur, `${S}_${S}`>; + +// The string literal doubles on every iteration. +type Explode = { +>Explode : Explode + + [P in Recur<5, "a"> as `${P}_key`]: any; +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { +>ExplodeSpans : ExplodeSpans + + [P in Recur<5, string> as `${P}_key`]: any; +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +>A16 : "aaaaaaaaaaaaaaaa" + +type A64 = `${A16}${A16}${A16}${A16}`; +>A64 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type A256 = `${A64}${A64}${A64}${A64}`; +>A256 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type A1024 = `${A256}${A256}${A256}${A256}`; +>A1024 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type RecurSegments = +>RecurSegments : RecurSegments + + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + +type ExplodeSegments = { +>ExplodeSegments : ExplodeSegments + + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +}; + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.symbols b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.symbols new file mode 100644 index 0000000000000..f2753a2cd94e0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.symbols @@ -0,0 +1,76 @@ +//// [tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts] //// + +=== typeParameterDefaultInCallInsideGenericCallback.ts === +// The default of T applies to the call inside the callback passed to another +// generic function as it does elsewhere, so data is accepted. + +declare function fetcher(cfg: unknown): Promise; +>fetcher : Symbol(fetcher, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 0, 0)) +>D : Symbol(D, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 25)) +>cfg : Symbol(cfg, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 28)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>D : Symbol(D, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 25)) + +type Routes = R extends 'x' ? { IN: { v: number }, OUT: string } : never; +>Routes : Symbol(Routes, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 54)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 12)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 12)) +>IN : Symbol(IN, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 34)) +>v : Symbol(v, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 40)) +>OUT : Symbol(OUT, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 53)) + +function executeFetch>( +>executeFetch : Symbol(executeFetch, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 76)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 22)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>Routes : Symbol(Routes, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 54)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 22)) + + route: R, +>route : Symbol(route, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 55)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 22)) + + body?: T extends Record<'IN', any> ? T['IN'] : never +>body : Symbol(body, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 8, 11)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) + +) { + return fetcher ? T['OUT'] : T>({ route, body }); +>fetcher : Symbol(fetcher, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 0, 0)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>route : Symbol(route, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 11, 63)) +>body : Symbol(body, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 11, 70)) +} + +declare function useCallback(cb: T, deps: unknown[]): T; +>useCallback : Symbol(useCallback, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 12, 1)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 29)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>cb : Symbol(cb, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 49)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 29)) +>deps : Symbol(deps, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 55)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 29)) + +export const cb = useCallback((data: { v: number }) => { +>cb : Symbol(cb, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 12)) +>useCallback : Symbol(useCallback, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 12, 1)) +>data : Symbol(data, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 31)) +>v : Symbol(v, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 38)) + + return executeFetch('x', data); +>executeFetch : Symbol(executeFetch, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 76)) +>data : Symbol(data, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 31)) + +}, []); + +export const check: Promise = cb({ v: 1 }); +>check : Symbol(check, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 20, 12)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>cb : Symbol(cb, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 12)) +>v : Symbol(v, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 20, 42)) + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.types b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.types new file mode 100644 index 0000000000000..ed2acda45dd86 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts] //// + +=== typeParameterDefaultInCallInsideGenericCallback.ts === +// The default of T applies to the call inside the callback passed to another +// generic function as it does elsewhere, so data is accepted. + +declare function fetcher(cfg: unknown): Promise; +>fetcher : (cfg: unknown) => Promise +>cfg : unknown + +type Routes = R extends 'x' ? { IN: { v: number }, OUT: string } : never; +>Routes : Routes +>IN : { v: number; } +>v : number +>OUT : string + +function executeFetch>( +>executeFetch : >(route: R, body?: T extends Record<'IN', any> ? T['IN'] : never) => Promise ? T["OUT"] : T> + + route: R, +>route : R + + body?: T extends Record<'IN', any> ? T['IN'] : never +>body : (T extends Record<"IN", any> ? T["IN"] : never) | undefined + +) { + return fetcher ? T['OUT'] : T>({ route, body }); +>fetcher ? T['OUT'] : T>({ route, body }) : Promise ? T["OUT"] : T> +>fetcher : (cfg: unknown) => Promise +>{ route, body } : { route: R; body: (T extends Record<"IN", any> ? T["IN"] : never) | undefined; } +>route : R +>body : (T extends Record<"IN", any> ? T["IN"] : never) | undefined +} + +declare function useCallback(cb: T, deps: unknown[]): T; +>useCallback : (cb: T, deps: unknown[]) => T +>cb : T +>deps : unknown[] + +export const cb = useCallback((data: { v: number }) => { +>cb : (data: { v: number; }) => Promise +>useCallback((data: { v: number }) => { return executeFetch('x', data);}, []) : (data: { v: number; }) => Promise +>useCallback : (cb: T, deps: unknown[]) => T +>(data: { v: number }) => { return executeFetch('x', data);} : (data: { v: number; }) => Promise +>data : { v: number; } +>v : number + + return executeFetch('x', data); +>executeFetch('x', data) : Promise +>executeFetch : >(route: R, body?: T extends Record<'IN', any> ? T['IN'] : never) => Promise ? T["OUT"] : T> +>'x' : "x" +>data : { v: number; } + +}, []); +>[] : never[] + +export const check: Promise = cb({ v: 1 }); +>check : Promise +>cb({ v: 1 }) : Promise +>cb : (data: { v: number; }) => Promise +>{ v: 1 } : { v: number; } +>v : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).errors.txt new file mode 100644 index 0000000000000..b7a0b982aceb6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).errors.txt @@ -0,0 +1,15 @@ +typeParameterHasSelfAsConstraint.ts(1,24): error TS2313: Type parameter 'T' has a circular constraint. +typeParameterHasSelfAsConstraint.ts(2,5): error TS2322: Type 'T' is not assignable to type 'number'. + + +==== typeParameterHasSelfAsConstraint.ts (2 errors) ==== + function foo(x: T): number { + ~ +!!! error TS2313: Type parameter 'T' has a circular constraint. + return x; + ~~~~~~ +!!! error TS2322: Type 'T' is not assignable to type 'number'. +!!! related TS2208 typeParameterHasSelfAsConstraint.ts:1:14: This type parameter might need an `extends number` constraint. + } + + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).js new file mode 100644 index 0000000000000..2b6ae7f2bca3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).js @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +//// [typeParameterHasSelfAsConstraint.ts] +function foo(x: T): number { + return x; +} + + + +//// [typeParameterHasSelfAsConstraint.js] +"use strict"; +function foo(x) { + return x; +} diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).symbols new file mode 100644 index 0000000000000..e8a52432a83dc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +=== typeParameterHasSelfAsConstraint.ts === +function foo(x: T): number { +>foo : Symbol(foo, Decl(typeParameterHasSelfAsConstraint.ts, 0, 0)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) +>x : Symbol(x, Decl(typeParameterHasSelfAsConstraint.ts, 0, 26)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) + + return x; +>x : Symbol(x, Decl(typeParameterHasSelfAsConstraint.ts, 0, 26)) +} + + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).types new file mode 100644 index 0000000000000..dd8af60e8c209 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).types @@ -0,0 +1,12 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +=== typeParameterHasSelfAsConstraint.ts === +function foo(x: T): number { +>foo : (x: T) => number +>x : T + + return x; +>x : T +} + + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..b7a0b982aceb6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt @@ -0,0 +1,15 @@ +typeParameterHasSelfAsConstraint.ts(1,24): error TS2313: Type parameter 'T' has a circular constraint. +typeParameterHasSelfAsConstraint.ts(2,5): error TS2322: Type 'T' is not assignable to type 'number'. + + +==== typeParameterHasSelfAsConstraint.ts (2 errors) ==== + function foo(x: T): number { + ~ +!!! error TS2313: Type parameter 'T' has a circular constraint. + return x; + ~~~~~~ +!!! error TS2322: Type 'T' is not assignable to type 'number'. +!!! related TS2208 typeParameterHasSelfAsConstraint.ts:1:14: This type parameter might need an `extends number` constraint. + } + + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).js new file mode 100644 index 0000000000000..2b6ae7f2bca3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).js @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +//// [typeParameterHasSelfAsConstraint.ts] +function foo(x: T): number { + return x; +} + + + +//// [typeParameterHasSelfAsConstraint.js] +"use strict"; +function foo(x) { + return x; +} diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..e8a52432a83dc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +=== typeParameterHasSelfAsConstraint.ts === +function foo(x: T): number { +>foo : Symbol(foo, Decl(typeParameterHasSelfAsConstraint.ts, 0, 0)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) +>x : Symbol(x, Decl(typeParameterHasSelfAsConstraint.ts, 0, 26)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) + + return x; +>x : Symbol(x, Decl(typeParameterHasSelfAsConstraint.ts, 0, 26)) +} + + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).types new file mode 100644 index 0000000000000..dd8af60e8c209 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).types @@ -0,0 +1,12 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +=== typeParameterHasSelfAsConstraint.ts === +function foo(x: T): number { +>foo : (x: T) => number +>x : T + + return x; +>x : T +} + + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterWithInvalidConstraintType.errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterWithInvalidConstraintType.errors.txt index 7ee5828671802..342cb732ba6ff 100644 --- a/tsc/testdata/baselines/reference/compiler/typeParameterWithInvalidConstraintType.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/typeParameterWithInvalidConstraintType.errors.txt @@ -10,7 +10,6 @@ typeParameterWithInvalidConstraintType.ts(7,17): error TS2349: This expression i class A { ~ !!! error TS2313: Type parameter 'T' has a circular constraint. -!!! related TS2751 typeParameterWithInvalidConstraintType.ts:4:17: Circularity originates in type at this location. foo() { var x!: T; var a = x.foo(); diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..6e024512e0b5b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,54 @@ +typeReferenceRecursionIdentityCheckOrder.ts(11,7): error TS2322: Type 'never[]' is not assignable to type 'A<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. +typeReferenceRecursionIdentityCheckOrder.ts(12,7): error TS2322: Type 'never[]' is not assignable to type 'B<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + + +==== typeReferenceRecursionIdentityCheckOrder.ts (2 errors) ==== + // Comparing never[] to B<0> nests comparisons of the members of A and B. + // Whether they are cut short as deeply nested must not depend on whether the + // annotation of b is resolved before checking a instantiates slice. + + interface A { + slice(): B; + every(predicate: (value: T) => value is S): this is A; + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; + } + interface B extends A {} + const a: A<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'A<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + const b: B<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'B<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..44770d906e0ac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + slice(): B; +>slice : Symbol(A.slice, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 16)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + every(predicate: (value: T) => value is S): this is A; +>every : Symbol(A.every, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 5, 18)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>predicate : Symbol(predicate, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 23)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : Symbol(A.flatMap, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 74)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>callback : Symbol(callback, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 15)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 26)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +} +interface B extends A {} +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) + +const a: A<0> = []; +>a : Symbol(a, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 10, 5)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) + +const b: B<0> = []; +>b : Symbol(b, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 11, 5)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) + diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..bab8645e582b3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { + slice(): B; +>slice : () => B + + every(predicate: (value: T) => value is S): this is A; +>every : (predicate: (value: T) => value is S) => this is A +>predicate : (value: T) => value is S +>value : T + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : (callback: (value: T) => U | readonly U[] | A) => U[] +>callback : (value: T) => U | readonly U[] | A +>value : T +} +interface B extends A {} +const a: A<0> = []; +>a : A<0> +>[] : never[] + +const b: B<0> = []; +>b : B<0> +>[] : never[] + diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..6e024512e0b5b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,54 @@ +typeReferenceRecursionIdentityCheckOrder.ts(11,7): error TS2322: Type 'never[]' is not assignable to type 'A<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. +typeReferenceRecursionIdentityCheckOrder.ts(12,7): error TS2322: Type 'never[]' is not assignable to type 'B<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + + +==== typeReferenceRecursionIdentityCheckOrder.ts (2 errors) ==== + // Comparing never[] to B<0> nests comparisons of the members of A and B. + // Whether they are cut short as deeply nested must not depend on whether the + // annotation of b is resolved before checking a instantiates slice. + + interface A { + slice(): B; + every(predicate: (value: T) => value is S): this is A; + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; + } + interface B extends A {} + const a: A<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'A<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + const b: B<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'B<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..44770d906e0ac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + slice(): B; +>slice : Symbol(A.slice, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 16)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + every(predicate: (value: T) => value is S): this is A; +>every : Symbol(A.every, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 5, 18)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>predicate : Symbol(predicate, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 23)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : Symbol(A.flatMap, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 74)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>callback : Symbol(callback, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 15)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 26)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +} +interface B extends A {} +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) + +const a: A<0> = []; +>a : Symbol(a, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 10, 5)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) + +const b: B<0> = []; +>b : Symbol(b, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 11, 5)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) + diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..bab8645e582b3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { + slice(): B; +>slice : () => B + + every(predicate: (value: T) => value is S): this is A; +>every : (predicate: (value: T) => value is S) => this is A +>predicate : (value: T) => value is S +>value : T + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : (callback: (value: T) => U | readonly U[] | A) => U[] +>callback : (value: T) => U | readonly U[] | A +>value : T +} +interface B extends A {} +const a: A<0> = []; +>a : A<0> +>[] : never[] + +const b: B<0> = []; +>b : B<0> +>[] : never[] + diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).errors.txt new file mode 100644 index 0000000000000..f2bff262ffc44 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).errors.txt @@ -0,0 +1,28 @@ +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(1,18): error TS6133: 'person' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(1,34): error TS6133: 'person2' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(2,9): error TS6133: 'unused' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(3,14): error TS6133: 'maker' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(3,20): error TS6133: 'child' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(4,13): error TS6133: 'unused2' is declared but its value is never read. + + +==== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts (6 errors) ==== + function greeter(person: string, person2: string) { + ~~~~~~ +!!! error TS6133: 'person' is declared but its value is never read. + ~~~~~~~ +!!! error TS6133: 'person2' is declared but its value is never read. + var unused = 20; + ~~~~~~ +!!! error TS6133: 'unused' is declared but its value is never read. + function maker(child: string): void { + ~~~~~ +!!! error TS6133: 'maker' is declared but its value is never read. + ~~~~~ +!!! error TS6133: 'child' is declared but its value is never read. + var unused2 = 22; + ~~~~~~~ +!!! error TS6133: 'unused2' is declared but its value is never read. + } + person2 = "dummy value"; + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).js new file mode 100644 index 0000000000000..9457d5135a002 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +//// [unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] +function greeter(person: string, person2: string) { + var unused = 20; + function maker(child: string): void { + var unused2 = 22; + } + person2 = "dummy value"; +} + +//// [unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.js] +"use strict"; +function greeter(person, person2) { + var unused = 20; + function maker(child) { + var unused2 = 22; + } + person2 = "dummy value"; +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).symbols new file mode 100644 index 0000000000000..7f6c7e03b1461 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).symbols @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +=== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts === +function greeter(person: string, person2: string) { +>greeter : Symbol(greeter, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 0)) +>person : Symbol(person, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 17)) +>person2 : Symbol(person2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 32)) + + var unused = 20; +>unused : Symbol(unused, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 1, 7)) + + function maker(child: string): void { +>maker : Symbol(maker, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 1, 20)) +>child : Symbol(child, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 2, 19)) + + var unused2 = 22; +>unused2 : Symbol(unused2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 3, 11)) + } + person2 = "dummy value"; +>person2 : Symbol(person2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 32)) +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).types new file mode 100644 index 0000000000000..0a0c9a1359a5f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).types @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +=== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts === +function greeter(person: string, person2: string) { +>greeter : (person: string, person2: string) => void +>person : string +>person2 : string + + var unused = 20; +>unused : number +>20 : 20 + + function maker(child: string): void { +>maker : (child: string) => void +>child : string + + var unused2 = 22; +>unused2 : number +>22 : 22 + } + person2 = "dummy value"; +>person2 = "dummy value" : "dummy value" +>person2 : string +>"dummy value" : "dummy value" +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..f2bff262ffc44 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt @@ -0,0 +1,28 @@ +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(1,18): error TS6133: 'person' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(1,34): error TS6133: 'person2' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(2,9): error TS6133: 'unused' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(3,14): error TS6133: 'maker' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(3,20): error TS6133: 'child' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(4,13): error TS6133: 'unused2' is declared but its value is never read. + + +==== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts (6 errors) ==== + function greeter(person: string, person2: string) { + ~~~~~~ +!!! error TS6133: 'person' is declared but its value is never read. + ~~~~~~~ +!!! error TS6133: 'person2' is declared but its value is never read. + var unused = 20; + ~~~~~~ +!!! error TS6133: 'unused' is declared but its value is never read. + function maker(child: string): void { + ~~~~~ +!!! error TS6133: 'maker' is declared but its value is never read. + ~~~~~ +!!! error TS6133: 'child' is declared but its value is never read. + var unused2 = 22; + ~~~~~~~ +!!! error TS6133: 'unused2' is declared but its value is never read. + } + person2 = "dummy value"; + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).js new file mode 100644 index 0000000000000..9457d5135a002 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +//// [unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] +function greeter(person: string, person2: string) { + var unused = 20; + function maker(child: string): void { + var unused2 = 22; + } + person2 = "dummy value"; +} + +//// [unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.js] +"use strict"; +function greeter(person, person2) { + var unused = 20; + function maker(child) { + var unused2 = 22; + } + person2 = "dummy value"; +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..7f6c7e03b1461 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).symbols @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +=== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts === +function greeter(person: string, person2: string) { +>greeter : Symbol(greeter, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 0)) +>person : Symbol(person, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 17)) +>person2 : Symbol(person2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 32)) + + var unused = 20; +>unused : Symbol(unused, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 1, 7)) + + function maker(child: string): void { +>maker : Symbol(maker, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 1, 20)) +>child : Symbol(child, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 2, 19)) + + var unused2 = 22; +>unused2 : Symbol(unused2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 3, 11)) + } + person2 = "dummy value"; +>person2 : Symbol(person2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 32)) +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).types new file mode 100644 index 0000000000000..0a0c9a1359a5f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).types @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +=== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts === +function greeter(person: string, person2: string) { +>greeter : (person: string, person2: string) => void +>person : string +>person2 : string + + var unused = 20; +>unused : number +>20 : 20 + + function maker(child: string): void { +>maker : (child: string) => void +>child : string + + var unused2 = 22; +>unused2 : number +>22 : 22 + } + person2 = "dummy value"; +>person2 = "dummy value" : "dummy value" +>person2 : string +>"dummy value" : "dummy value" +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.symbols b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.symbols new file mode 100644 index 0000000000000..7920b1fa322d0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.symbols @@ -0,0 +1,74 @@ +//// [tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts] //// + +=== unusedLocalsReferencedInCycleDuringCheck.ts === +// Checking the call resolves it within a cycle of flow analysis, during which +// what checking computes is recorded, yet its references are still uses. + +declare const assert: { deepStrictEqual(actual: unknown, expected: T): asserts actual is T }; +>assert : Symbol(assert, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 13)) +>deepStrictEqual : Symbol(deepStrictEqual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 23)) +>T : Symbol(T, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 40)) +>actual : Symbol(actual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 43)) +>expected : Symbol(expected, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 59)) +>T : Symbol(T, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 40)) +>actual : Symbol(actual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 43)) +>T : Symbol(T, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 40)) + +declare function make(): { width: number }; +>make : Symbol(make, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 96)) +>width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) + +export function test() { +>test : Symbol(test, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 43)) + + const first = make(); +>first : Symbol(first, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 6, 6)) +>make : Symbol(make, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 96)) + + let baseline: number[][] | undefined; +>baseline : Symbol(baseline, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 7, 4)) + + const geometry = () => [first].map(e => [e.width]); +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 6)) +>[first].map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>first : Symbol(first, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 6, 6)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>e : Symbol(e, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 36)) +>e.width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) +>e : Symbol(e, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 36)) +>width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) + + for (const themeType of ['a', 'b']) { +>themeType : Symbol(themeType, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 9, 11)) + + baseline ??= geometry(); +>baseline : Symbol(baseline, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 7, 4)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 6)) + + for (const active of [true, false]) { +>active : Symbol(active, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 11, 12)) + + const border = active ? themeType : 'x'; +>border : Symbol(border, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 12, 8)) +>active : Symbol(active, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 11, 12)) +>themeType : Symbol(themeType, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 9, 11)) + + assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }); +>assert.deepStrictEqual : Symbol(deepStrictEqual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 23)) +>assert : Symbol(assert, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 13)) +>deepStrictEqual : Symbol(deepStrictEqual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 23)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 27)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 6)) +>w : Symbol(w, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 49)) +>first.width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) +>first : Symbol(first, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 6, 6)) +>width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) +>border : Symbol(border, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 65)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 77)) +>baseline : Symbol(baseline, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 7, 4)) +>w : Symbol(w, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 97)) +>border : Symbol(border, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 103)) + } + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.types b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.types new file mode 100644 index 0000000000000..c2b73c9bc9146 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.types @@ -0,0 +1,92 @@ +//// [tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts] //// + +=== unusedLocalsReferencedInCycleDuringCheck.ts === +// Checking the call resolves it within a cycle of flow analysis, during which +// what checking computes is recorded, yet its references are still uses. + +declare const assert: { deepStrictEqual(actual: unknown, expected: T): asserts actual is T }; +>assert : { deepStrictEqual(actual: unknown, expected: T): asserts actual is T; } +>deepStrictEqual : (actual: unknown, expected: T) => asserts actual is T +>actual : unknown +>expected : T + +declare function make(): { width: number }; +>make : () => { width: number; } +>width : number + +export function test() { +>test : () => void + + const first = make(); +>first : { width: number; } +>make() : { width: number; } +>make : () => { width: number; } + + let baseline: number[][] | undefined; +>baseline : number[][] | undefined + + const geometry = () => [first].map(e => [e.width]); +>geometry : () => number[][] +>() => [first].map(e => [e.width]) : () => number[][] +>[first].map(e => [e.width]) : number[][] +>[first].map : (callbackfn: (value: { width: number; }, index: number, array: { width: number; }[]) => U, thisArg?: any) => U[] +>[first] : { width: number; }[] +>first : { width: number; } +>map : (callbackfn: (value: { width: number; }, index: number, array: { width: number; }[]) => U, thisArg?: any) => U[] +>e => [e.width] : (e: { width: number; }) => number[] +>e : { width: number; } +>[e.width] : number[] +>e.width : number +>e : { width: number; } +>width : number + + for (const themeType of ['a', 'b']) { +>themeType : string +>['a', 'b'] : string[] +>'a' : "a" +>'b' : "b" + + baseline ??= geometry(); +>baseline ??= geometry() : number[][] +>baseline : number[][] | undefined +>geometry() : number[][] +>geometry : () => number[][] + + for (const active of [true, false]) { +>active : boolean +>[true, false] : boolean[] +>true : true +>false : false + + const border = active ? themeType : 'x'; +>border : string +>active ? themeType : 'x' : string +>active : boolean +>themeType : string +>'x' : "x" + + assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }); +>assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }) : void +>assert.deepStrictEqual : (actual: unknown, expected: T) => asserts actual is T +>assert : { deepStrictEqual(actual: unknown, expected: T): asserts actual is T; } +>deepStrictEqual : (actual: unknown, expected: T) => asserts actual is T +>{ geometry: geometry(), w: first.width, border } : { geometry: number[][]; w: number; border: string; } +>geometry : number[][] +>geometry() : number[][] +>geometry : () => number[][] +>w : number +>first.width : number +>first : { width: number; } +>width : number +>border : string +>{ geometry: baseline, w: 0, border: '' } : { geometry: number[][]; w: number; border: string; } +>geometry : number[][] +>baseline : number[][] +>w : number +>0 : 0 +>border : string +>'' : "" + } + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..55aecda78cdca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).errors.txt @@ -0,0 +1,12 @@ +unusedTypeParameterQueryOrder.ts(3,17): error TS6196: 'T' is declared but never used. + + +==== unusedTypeParameterQueryOrder.ts (1 errors) ==== + class A { + f() { + return () => {}; + ~ +!!! error TS6196: 'T' is declared but never used. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..7bbfd20d663d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).js @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +//// [unusedTypeParameterQueryOrder.ts] +class A { + f() { + return () => {}; + } +} + + +//// [unusedTypeParameterQueryOrder.js] +"use strict"; +class A { + f() { + return () => { }; + } +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..827db0c67998a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).symbols @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : Symbol(A, Decl(unusedTypeParameterQueryOrder.ts, 0, 0)) + + f() { +>f : Symbol(A.f, Decl(unusedTypeParameterQueryOrder.ts, 0, 9)) + + return () => {}; +>T : Symbol(T, Decl(unusedTypeParameterQueryOrder.ts, 2, 16)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..0f1b46b9de35e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).types @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : A + + f() { +>f : () => () => void + + return () => {}; +>() => {} : () => void + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..55aecda78cdca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,12 @@ +unusedTypeParameterQueryOrder.ts(3,17): error TS6196: 'T' is declared but never used. + + +==== unusedTypeParameterQueryOrder.ts (1 errors) ==== + class A { + f() { + return () => {}; + ~ +!!! error TS6196: 'T' is declared but never used. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..7bbfd20d663d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +//// [unusedTypeParameterQueryOrder.ts] +class A { + f() { + return () => {}; + } +} + + +//// [unusedTypeParameterQueryOrder.js] +"use strict"; +class A { + f() { + return () => { }; + } +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..827db0c67998a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : Symbol(A, Decl(unusedTypeParameterQueryOrder.ts, 0, 0)) + + f() { +>f : Symbol(A.f, Decl(unusedTypeParameterQueryOrder.ts, 0, 9)) + + return () => {}; +>T : Symbol(T, Decl(unusedTypeParameterQueryOrder.ts, 2, 16)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..0f1b46b9de35e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : A + + f() { +>f : () => () => void + + return () => {}; +>() => {} : () => void + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt b/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt index 38d1631f0deab..3ccd49b9642ed 100644 --- a/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt @@ -14,8 +14,11 @@ useBeforeDeclaration_classDecorators.2.ts(41,10): error TS2449: Class 'C5' used useBeforeDeclaration_classDecorators.2.ts(42,10): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(43,10): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(46,17): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(46,22): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(47,20): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(47,25): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(48,13): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(48,18): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(53,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(54,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(55,17): error TS2449: Class 'C6' used before its declaration. @@ -27,11 +30,14 @@ useBeforeDeclaration_classDecorators.2.ts(61,17): error TS2449: Class 'C6' used useBeforeDeclaration_classDecorators.2.ts(62,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(63,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(66,17): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(66,29): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(67,20): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(67,32): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(68,13): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(68,25): error TS2449: Class 'C6' used before its declaration. -==== useBeforeDeclaration_classDecorators.2.ts (31 errors) ==== +==== useBeforeDeclaration_classDecorators.2.ts (37 errors) ==== declare const dec: any; // ok @@ -122,12 +128,21 @@ useBeforeDeclaration_classDecorators.2.ts(68,13): error TS1206: Decorators are n constructor(@dec(C5) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C5' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:32:7: 'C5' is declared here. static method2(@dec(C5) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C5' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:32:7: 'C5' is declared here. method2(@dec(C5) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C5' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:32:7: 'C5' is declared here. } // error @@ -178,11 +193,20 @@ useBeforeDeclaration_classDecorators.2.ts(68,13): error TS1206: Decorators are n constructor(@dec((() => C6)()) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C6' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:52:7: 'C6' is declared here. static method2(@dec((() => C6)()) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C6' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:52:7: 'C6' is declared here. method2(@dec((() => C6)()) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C6' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:52:7: 'C6' is declared here. } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt new file mode 100644 index 0000000000000..060c23148616c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt @@ -0,0 +1,66 @@ +varianceCircularConsistency.ts(25,7): error TS2322: Type 'EntryPoint void; }, {}>, { slug: string; }>' is not assignable to type 'EntryPoint'. + Types of property 'root' are incompatible. + Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. + Type 'EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>' is not assignable to type 'EntryPointComponent, never, never, {}>'. + Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type 'EntryPointComponent, never, never, {}>'. + Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type '(props: Props, never, never, {}>) => void'. + Types of parameters 'props' and 'props' are incompatible. + Type 'Props, never, never, {}>' is not assignable to type 'Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>'. + Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. +varianceCircularConsistency.ts(26,7): error TS2322: Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. + Type 'EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>' is not assignable to type 'EntryPointComponent, never, never, {}>'. + Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type 'EntryPointComponent, never, never, {}>'. + Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type '(props: Props, never, never, {}>) => void'. + Types of parameters 'props' and 'props' are incompatible. + Type 'Props, never, never, {}>' is not assignable to type 'Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>'. + Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. + + +==== varianceCircularConsistency.ts (2 errors) ==== + // Variances of these mutually recursive generics must not depend on values + // measured mid-cycle. Assigning `e` to `EntryPoint` must agree with + // assigning `e.root` to `EntryPoint["root"]`. + + interface Query {} + type Component

= P | ((props: P) => void); + interface Ref { + value: T; + } + interface Rep, Nested, Runtime, Extra> extends Readonly<{ + root: Ref>; + }> {} + type Preloaded = T extends Record> ? { [K in keyof T]: Unwrap> } : never; + interface Props extends Readonly<{ + nested: Preloaded; + queries: Queries; + }> {} + type EntryPointComponent, Nested, Runtime, Extra = {}> = Component>; + type Unwrap = C extends EntryPointComponent ? Readonly<{}> : {}; + type EntryPoint = Rep ? Q : never, never, never, never>; + type GetComponent = T extends EntryPoint ? C : never; + + declare const c: EntryPointComponent<{ q: { readonly variables: { slug: string } } }, {}, { onClick: () => void }>; + declare const e: EntryPoint; + const whole: EntryPoint = e; + ~~~~~ +!!! error TS2322: Type 'EntryPoint void; }, {}>, { slug: string; }>' is not assignable to type 'EntryPoint'. +!!! error TS2322: Types of property 'root' are incompatible. +!!! error TS2322: Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. +!!! error TS2322: Type 'EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>' is not assignable to type 'EntryPointComponent, never, never, {}>'. +!!! error TS2322: Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type 'EntryPointComponent, never, never, {}>'. +!!! error TS2322: Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type '(props: Props, never, never, {}>) => void'. +!!! error TS2322: Types of parameters 'props' and 'props' are incompatible. +!!! error TS2322: Type 'Props, never, never, {}>' is not assignable to type 'Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>'. +!!! error TS2322: Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. +!!! related TS2728 varianceCircularConsistency.ts:23:40: 'q' is declared here. + const root: EntryPoint["root"] = e.root; + ~~~~ +!!! error TS2322: Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. +!!! error TS2322: Type 'EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>' is not assignable to type 'EntryPointComponent, never, never, {}>'. +!!! error TS2322: Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type 'EntryPointComponent, never, never, {}>'. +!!! error TS2322: Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type '(props: Props, never, never, {}>) => void'. +!!! error TS2322: Types of parameters 'props' and 'props' are incompatible. +!!! error TS2322: Type 'Props, never, never, {}>' is not assignable to type 'Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>'. +!!! error TS2322: Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. +!!! related TS2728 varianceCircularConsistency.ts:23:40: 'q' is declared here. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.symbols b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.symbols new file mode 100644 index 0000000000000..648c66a010864 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.symbols @@ -0,0 +1,146 @@ +//// [tests/cases/compiler/varianceCircularConsistency.ts] //// + +=== varianceCircularConsistency.ts === +// Variances of these mutually recursive generics must not depend on values +// measured mid-cycle. Assigning `e` to `EntryPoint` must agree with +// assigning `e.root` to `EntryPoint["root"]`. + +interface Query {} +>Query : Symbol(Query, Decl(varianceCircularConsistency.ts, 0, 0)) + +type Component

= P | ((props: P) => void); +>Component : Symbol(Component, Decl(varianceCircularConsistency.ts, 4, 18)) +>P : Symbol(P, Decl(varianceCircularConsistency.ts, 5, 15)) +>P : Symbol(P, Decl(varianceCircularConsistency.ts, 5, 15)) +>props : Symbol(props, Decl(varianceCircularConsistency.ts, 5, 26)) +>P : Symbol(P, Decl(varianceCircularConsistency.ts, 5, 15)) + +interface Ref { +>Ref : Symbol(Ref, Decl(varianceCircularConsistency.ts, 5, 45)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 6, 14)) + + value: T; +>value : Symbol(Ref.value, Decl(varianceCircularConsistency.ts, 6, 18)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 6, 14)) +} +interface Rep, Nested, Runtime, Extra> extends Readonly<{ +>Rep : Symbol(Rep, Decl(varianceCircularConsistency.ts, 8, 1)) +>Params : Symbol(Params, Decl(varianceCircularConsistency.ts, 9, 14)) +>Queries : Symbol(Queries, Decl(varianceCircularConsistency.ts, 9, 21)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Query : Symbol(Query, Decl(varianceCircularConsistency.ts, 0, 0)) +>Nested : Symbol(Nested, Decl(varianceCircularConsistency.ts, 9, 60)) +>Runtime : Symbol(Runtime, Decl(varianceCircularConsistency.ts, 9, 68)) +>Extra : Symbol(Extra, Decl(varianceCircularConsistency.ts, 9, 77)) +>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --)) + + root: Ref>; +>root : Symbol(root, Decl(varianceCircularConsistency.ts, 9, 103)) +>Ref : Symbol(Ref, Decl(varianceCircularConsistency.ts, 5, 45)) +>EntryPointComponent : Symbol(EntryPointComponent, Decl(varianceCircularConsistency.ts, 16, 5)) +>Queries : Symbol(Queries, Decl(varianceCircularConsistency.ts, 9, 21)) +>Nested : Symbol(Nested, Decl(varianceCircularConsistency.ts, 9, 60)) +>Runtime : Symbol(Runtime, Decl(varianceCircularConsistency.ts, 9, 68)) + +}> {} +type Preloaded = T extends Record> ? { [K in keyof T]: Unwrap> } : never; +>Preloaded : Symbol(Preloaded, Decl(varianceCircularConsistency.ts, 11, 5)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 12, 15)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 12, 15)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Rep : Symbol(Rep, Decl(varianceCircularConsistency.ts, 8, 1)) +>K : Symbol(K, Decl(varianceCircularConsistency.ts, 12, 80)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 12, 15)) +>Unwrap : Symbol(Unwrap, Decl(varianceCircularConsistency.ts, 17, 145)) +>GetComponent : Symbol(GetComponent, Decl(varianceCircularConsistency.ts, 19, 124)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 12, 15)) + +interface Props extends Readonly<{ +>Props : Symbol(Props, Decl(varianceCircularConsistency.ts, 12, 129)) +>Queries : Symbol(Queries, Decl(varianceCircularConsistency.ts, 13, 16)) +>Nested : Symbol(Nested, Decl(varianceCircularConsistency.ts, 13, 24)) +>Runtime : Symbol(Runtime, Decl(varianceCircularConsistency.ts, 13, 32)) +>Extra : Symbol(Extra, Decl(varianceCircularConsistency.ts, 13, 41)) +>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --)) + + nested: Preloaded; +>nested : Symbol(nested, Decl(varianceCircularConsistency.ts, 13, 67)) +>Preloaded : Symbol(Preloaded, Decl(varianceCircularConsistency.ts, 11, 5)) +>Nested : Symbol(Nested, Decl(varianceCircularConsistency.ts, 13, 24)) + + queries: Queries; +>queries : Symbol(queries, Decl(varianceCircularConsistency.ts, 14, 30)) +>Queries : Symbol(Queries, Decl(varianceCircularConsistency.ts, 13, 16)) + +}> {} +type EntryPointComponent, Nested, Runtime, Extra = {}> = Component>; +>EntryPointComponent : Symbol(EntryPointComponent, Decl(varianceCircularConsistency.ts, 16, 5)) +>Queries : Symbol(Queries, Decl(varianceCircularConsistency.ts, 17, 25)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Query : Symbol(Query, Decl(varianceCircularConsistency.ts, 0, 0)) +>Nested : Symbol(Nested, Decl(varianceCircularConsistency.ts, 17, 63)) +>Runtime : Symbol(Runtime, Decl(varianceCircularConsistency.ts, 17, 71)) +>Extra : Symbol(Extra, Decl(varianceCircularConsistency.ts, 17, 80)) +>Component : Symbol(Component, Decl(varianceCircularConsistency.ts, 4, 18)) +>Props : Symbol(Props, Decl(varianceCircularConsistency.ts, 12, 129)) +>Queries : Symbol(Queries, Decl(varianceCircularConsistency.ts, 17, 25)) +>Nested : Symbol(Nested, Decl(varianceCircularConsistency.ts, 17, 63)) +>Runtime : Symbol(Runtime, Decl(varianceCircularConsistency.ts, 17, 71)) +>Extra : Symbol(Extra, Decl(varianceCircularConsistency.ts, 17, 80)) + +type Unwrap = C extends EntryPointComponent ? Readonly<{}> : {}; +>Unwrap : Symbol(Unwrap, Decl(varianceCircularConsistency.ts, 17, 145)) +>C : Symbol(C, Decl(varianceCircularConsistency.ts, 18, 12)) +>C : Symbol(C, Decl(varianceCircularConsistency.ts, 18, 12)) +>EntryPointComponent : Symbol(EntryPointComponent, Decl(varianceCircularConsistency.ts, 16, 5)) +>Q : Symbol(Q, Decl(varianceCircularConsistency.ts, 18, 52)) +>N : Symbol(N, Decl(varianceCircularConsistency.ts, 18, 61)) +>R : Symbol(R, Decl(varianceCircularConsistency.ts, 18, 70)) +>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --)) + +type EntryPoint = Rep ? Q : never, never, never, never>; +>EntryPoint : Symbol(EntryPoint, Decl(varianceCircularConsistency.ts, 18, 94)) +>C : Symbol(C, Decl(varianceCircularConsistency.ts, 19, 16)) +>Params : Symbol(Params, Decl(varianceCircularConsistency.ts, 19, 18)) +>Rep : Symbol(Rep, Decl(varianceCircularConsistency.ts, 8, 1)) +>Params : Symbol(Params, Decl(varianceCircularConsistency.ts, 19, 18)) +>C : Symbol(C, Decl(varianceCircularConsistency.ts, 19, 16)) +>EntryPointComponent : Symbol(EntryPointComponent, Decl(varianceCircularConsistency.ts, 16, 5)) +>Q : Symbol(Q, Decl(varianceCircularConsistency.ts, 19, 76)) +>Q : Symbol(Q, Decl(varianceCircularConsistency.ts, 19, 76)) + +type GetComponent = T extends EntryPoint ? C : never; +>GetComponent : Symbol(GetComponent, Decl(varianceCircularConsistency.ts, 19, 124)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 20, 18)) +>T : Symbol(T, Decl(varianceCircularConsistency.ts, 20, 18)) +>EntryPoint : Symbol(EntryPoint, Decl(varianceCircularConsistency.ts, 18, 94)) +>C : Symbol(C, Decl(varianceCircularConsistency.ts, 20, 49)) +>P : Symbol(P, Decl(varianceCircularConsistency.ts, 20, 58)) +>C : Symbol(C, Decl(varianceCircularConsistency.ts, 20, 49)) + +declare const c: EntryPointComponent<{ q: { readonly variables: { slug: string } } }, {}, { onClick: () => void }>; +>c : Symbol(c, Decl(varianceCircularConsistency.ts, 22, 13)) +>EntryPointComponent : Symbol(EntryPointComponent, Decl(varianceCircularConsistency.ts, 16, 5)) +>q : Symbol(q, Decl(varianceCircularConsistency.ts, 22, 38)) +>variables : Symbol(variables, Decl(varianceCircularConsistency.ts, 22, 43)) +>slug : Symbol(slug, Decl(varianceCircularConsistency.ts, 22, 65)) +>onClick : Symbol(onClick, Decl(varianceCircularConsistency.ts, 22, 91)) + +declare const e: EntryPoint; +>e : Symbol(e, Decl(varianceCircularConsistency.ts, 23, 13)) +>EntryPoint : Symbol(EntryPoint, Decl(varianceCircularConsistency.ts, 18, 94)) +>c : Symbol(c, Decl(varianceCircularConsistency.ts, 22, 13)) +>slug : Symbol(slug, Decl(varianceCircularConsistency.ts, 23, 39)) + +const whole: EntryPoint = e; +>whole : Symbol(whole, Decl(varianceCircularConsistency.ts, 24, 5)) +>EntryPoint : Symbol(EntryPoint, Decl(varianceCircularConsistency.ts, 18, 94)) +>e : Symbol(e, Decl(varianceCircularConsistency.ts, 23, 13)) + +const root: EntryPoint["root"] = e.root; +>root : Symbol(root, Decl(varianceCircularConsistency.ts, 25, 5)) +>EntryPoint : Symbol(EntryPoint, Decl(varianceCircularConsistency.ts, 18, 94)) +>e.root : Symbol(root, Decl(varianceCircularConsistency.ts, 9, 103)) +>e : Symbol(e, Decl(varianceCircularConsistency.ts, 23, 13)) +>root : Symbol(root, Decl(varianceCircularConsistency.ts, 9, 103)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.types b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.types new file mode 100644 index 0000000000000..28c105bfea8f1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.types @@ -0,0 +1,66 @@ +//// [tests/cases/compiler/varianceCircularConsistency.ts] //// + +=== varianceCircularConsistency.ts === +// Variances of these mutually recursive generics must not depend on values +// measured mid-cycle. Assigning `e` to `EntryPoint` must agree with +// assigning `e.root` to `EntryPoint["root"]`. + +interface Query {} +type Component

= P | ((props: P) => void); +>Component : Component

+>props : P + +interface Ref { + value: T; +>value : T +} +interface Rep, Nested, Runtime, Extra> extends Readonly<{ + root: Ref>; +>root : Ref> + +}> {} +type Preloaded = T extends Record> ? { [K in keyof T]: Unwrap> } : never; +>Preloaded : Preloaded + +interface Props extends Readonly<{ + nested: Preloaded; +>nested : Preloaded + + queries: Queries; +>queries : Queries + +}> {} +type EntryPointComponent, Nested, Runtime, Extra = {}> = Component>; +>EntryPointComponent : EntryPointComponent + +type Unwrap = C extends EntryPointComponent ? Readonly<{}> : {}; +>Unwrap : Unwrap + +type EntryPoint = Rep ? Q : never, never, never, never>; +>EntryPoint : EntryPoint + +type GetComponent = T extends EntryPoint ? C : never; +>GetComponent : GetComponent + +declare const c: EntryPointComponent<{ q: { readonly variables: { slug: string } } }, {}, { onClick: () => void }>; +>c : EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, {}, { onClick: () => void; }, {}> +>q : { readonly variables: { slug: string; }; } +>variables : { slug: string; } +>slug : string +>onClick : () => void + +declare const e: EntryPoint; +>e : EntryPoint void; }, {}>, { slug: string; }> +>c : EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, {}, { onClick: () => void; }, {}> +>slug : string + +const whole: EntryPoint = e; +>whole : EntryPoint +>e : EntryPoint void; }, {}>, { slug: string; }> + +const root: EntryPoint["root"] = e.root; +>root : Ref, never, never, {}>> +>e.root : Ref> +>e : EntryPoint void; }, {}>, { slug: string; }> +>root : Ref> + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).errors.txt new file mode 100644 index 0000000000000..4a1acaffb8ffb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).errors.txt @@ -0,0 +1,56 @@ +varianceCircularityEnteredByInference.ts(45,16): error TS2345: Argument of type 'AstObject' is not assignable to parameter of type 'AstObject'. + Property 'decorators' is missing in type 'Empty' but required in type 'WithDecorators'. + + +==== varianceCircularityEnteredByInference.ts (1 errors) ==== + // AstObject and AstValue form a variance circularity. AstValue is covariant + // in T through typeBrand, and AstObject reaches it through getValue, so + // AstObject is not assignable to AstObject and the + // call below must be an error. Checking getValue first infers the type + // arguments of `new AstValue` from its return type, which measures AstValue + // first; AstObject, measured inside it, then sees T only in references to + // the types in progress, and main recorded it as independent of T and + // accepted the call. Main reports the error when AstObject's variance is + // measured first. + + export {}; + + type ObjectType = T extends object ? T : never; + + class AstObject { + constructor(private host: E) {} + + getObject(key: K): AstObject, E> { + return new AstObject, E>(this.host); + } + + getValue(key: K): AstValue { + return new AstValue(this.host); + } + } + + class AstValue { + declare typeBrand: T; + + constructor(private host: E) {} + + getObject(): AstObject, E> { + return new AstObject(this.host); + } + } + + interface Empty {} + interface WithDecorators { + decorators: string; + } + + declare function useDerived(obj: AstObject): void; + + function useBase(obj: AstObject) { + useDerived(obj); + ~~~ +!!! error TS2345: Argument of type 'AstObject' is not assignable to parameter of type 'AstObject'. +!!! error TS2345: Property 'decorators' is missing in type 'Empty' but required in type 'WithDecorators'. +!!! related TS2728 varianceCircularityEnteredByInference.ts:39:5: 'decorators' is declared here. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).symbols new file mode 100644 index 0000000000000..7768a5de8fd45 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).symbols @@ -0,0 +1,129 @@ +//// [tests/cases/compiler/varianceCircularityEnteredByInference.ts] //// + +=== varianceCircularityEnteredByInference.ts === +// AstObject and AstValue form a variance circularity. AstValue is covariant +// in T through typeBrand, and AstObject reaches it through getValue, so +// AstObject is not assignable to AstObject and the +// call below must be an error. Checking getValue first infers the type +// arguments of `new AstValue` from its return type, which measures AstValue +// first; AstObject, measured inside it, then sees T only in references to +// the types in progress, and main recorded it as independent of T and +// accepted the call. Main reports the error when AstObject's variance is +// measured first. + +export {}; + +type ObjectType = T extends object ? T : never; +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 12, 16)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 12, 16)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 12, 16)) + +class AstObject { +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + constructor(private host: E) {} +>host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + getObject(key: K): AstObject, E> { +>getObject : Symbol(AstObject.getObject, Decl(varianceCircularityEnteredByInference.ts, 15, 35)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 17, 14)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>key : Symbol(key, Decl(varianceCircularityEnteredByInference.ts, 17, 42)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 17, 14)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + return new AstObject, E>(this.host); +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) +>this.host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) +>this : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) + } + + getValue(key: K): AstValue { +>getValue : Symbol(AstObject.getValue, Decl(varianceCircularityEnteredByInference.ts, 19, 5)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 21, 13)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>key : Symbol(key, Decl(varianceCircularityEnteredByInference.ts, 21, 41)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 21, 13)) +>AstValue : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 21, 13)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + return new AstValue(this.host); +>AstValue : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>this.host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) +>this : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) + } +} + +class AstValue { +>AstValue : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 26, 15)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 26, 17)) + + declare typeBrand: T; +>typeBrand : Symbol(AstValue.typeBrand, Decl(varianceCircularityEnteredByInference.ts, 26, 22)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 26, 15)) + + constructor(private host: E) {} +>host : Symbol(AstValue.host, Decl(varianceCircularityEnteredByInference.ts, 29, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 26, 17)) + + getObject(): AstObject, E> { +>getObject : Symbol(AstValue.getObject, Decl(varianceCircularityEnteredByInference.ts, 29, 35)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 26, 15)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 26, 17)) + + return new AstObject(this.host); +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>this.host : Symbol(AstValue.host, Decl(varianceCircularityEnteredByInference.ts, 29, 16)) +>this : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>host : Symbol(AstValue.host, Decl(varianceCircularityEnteredByInference.ts, 29, 16)) + } +} + +interface Empty {} +>Empty : Symbol(Empty, Decl(varianceCircularityEnteredByInference.ts, 34, 1)) + +interface WithDecorators { +>WithDecorators : Symbol(WithDecorators, Decl(varianceCircularityEnteredByInference.ts, 36, 18)) + + decorators: string; +>decorators : Symbol(WithDecorators.decorators, Decl(varianceCircularityEnteredByInference.ts, 37, 26)) +} + +declare function useDerived(obj: AstObject): void; +>useDerived : Symbol(useDerived, Decl(varianceCircularityEnteredByInference.ts, 39, 1)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 41, 28)) +>obj : Symbol(obj, Decl(varianceCircularityEnteredByInference.ts, 41, 31)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>WithDecorators : Symbol(WithDecorators, Decl(varianceCircularityEnteredByInference.ts, 36, 18)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 41, 28)) + +function useBase(obj: AstObject) { +>useBase : Symbol(useBase, Decl(varianceCircularityEnteredByInference.ts, 41, 72)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 43, 17)) +>obj : Symbol(obj, Decl(varianceCircularityEnteredByInference.ts, 43, 20)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>Empty : Symbol(Empty, Decl(varianceCircularityEnteredByInference.ts, 34, 1)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 43, 17)) + + useDerived(obj); +>useDerived : Symbol(useDerived, Decl(varianceCircularityEnteredByInference.ts, 39, 1)) +>obj : Symbol(obj, Decl(varianceCircularityEnteredByInference.ts, 43, 20)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).types new file mode 100644 index 0000000000000..264ad82ecb3f7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).types @@ -0,0 +1,90 @@ +//// [tests/cases/compiler/varianceCircularityEnteredByInference.ts] //// + +=== varianceCircularityEnteredByInference.ts === +// AstObject and AstValue form a variance circularity. AstValue is covariant +// in T through typeBrand, and AstObject reaches it through getValue, so +// AstObject is not assignable to AstObject and the +// call below must be an error. Checking getValue first infers the type +// arguments of `new AstValue` from its return type, which measures AstValue +// first; AstObject, measured inside it, then sees T only in references to +// the types in progress, and main recorded it as independent of T and +// accepted the call. Main reports the error when AstObject's variance is +// measured first. + +export {}; + +type ObjectType = T extends object ? T : never; +>ObjectType : ObjectType + +class AstObject { +>AstObject : AstObject + + constructor(private host: E) {} +>host : E + + getObject(key: K): AstObject, E> { +>getObject : (key: K) => AstObject, E> +>key : K + + return new AstObject, E>(this.host); +>new AstObject, E>(this.host) : AstObject, E> +>AstObject : typeof AstObject +>this.host : E +>this : this +>host : E + } + + getValue(key: K): AstValue { +>getValue : (key: K) => AstValue +>key : K + + return new AstValue(this.host); +>new AstValue(this.host) : AstValue +>AstValue : typeof AstValue +>this.host : E +>this : this +>host : E + } +} + +class AstValue { +>AstValue : AstValue + + declare typeBrand: T; +>typeBrand : T + + constructor(private host: E) {} +>host : E + + getObject(): AstObject, E> { +>getObject : () => AstObject, E> + + return new AstObject(this.host); +>new AstObject(this.host) : AstObject, E> +>AstObject : typeof AstObject +>this.host : E +>this : this +>host : E + } +} + +interface Empty {} +interface WithDecorators { + decorators: string; +>decorators : string +} + +declare function useDerived(obj: AstObject): void; +>useDerived : (obj: AstObject) => void +>obj : AstObject + +function useBase(obj: AstObject) { +>useBase : (obj: AstObject) => void +>obj : AstObject + + useDerived(obj); +>useDerived(obj) : void +>useDerived : (obj: AstObject) => void +>obj : AstObject +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..4a1acaffb8ffb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).errors.txt @@ -0,0 +1,56 @@ +varianceCircularityEnteredByInference.ts(45,16): error TS2345: Argument of type 'AstObject' is not assignable to parameter of type 'AstObject'. + Property 'decorators' is missing in type 'Empty' but required in type 'WithDecorators'. + + +==== varianceCircularityEnteredByInference.ts (1 errors) ==== + // AstObject and AstValue form a variance circularity. AstValue is covariant + // in T through typeBrand, and AstObject reaches it through getValue, so + // AstObject is not assignable to AstObject and the + // call below must be an error. Checking getValue first infers the type + // arguments of `new AstValue` from its return type, which measures AstValue + // first; AstObject, measured inside it, then sees T only in references to + // the types in progress, and main recorded it as independent of T and + // accepted the call. Main reports the error when AstObject's variance is + // measured first. + + export {}; + + type ObjectType = T extends object ? T : never; + + class AstObject { + constructor(private host: E) {} + + getObject(key: K): AstObject, E> { + return new AstObject, E>(this.host); + } + + getValue(key: K): AstValue { + return new AstValue(this.host); + } + } + + class AstValue { + declare typeBrand: T; + + constructor(private host: E) {} + + getObject(): AstObject, E> { + return new AstObject(this.host); + } + } + + interface Empty {} + interface WithDecorators { + decorators: string; + } + + declare function useDerived(obj: AstObject): void; + + function useBase(obj: AstObject) { + useDerived(obj); + ~~~ +!!! error TS2345: Argument of type 'AstObject' is not assignable to parameter of type 'AstObject'. +!!! error TS2345: Property 'decorators' is missing in type 'Empty' but required in type 'WithDecorators'. +!!! related TS2728 varianceCircularityEnteredByInference.ts:39:5: 'decorators' is declared here. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..7768a5de8fd45 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).symbols @@ -0,0 +1,129 @@ +//// [tests/cases/compiler/varianceCircularityEnteredByInference.ts] //// + +=== varianceCircularityEnteredByInference.ts === +// AstObject and AstValue form a variance circularity. AstValue is covariant +// in T through typeBrand, and AstObject reaches it through getValue, so +// AstObject is not assignable to AstObject and the +// call below must be an error. Checking getValue first infers the type +// arguments of `new AstValue` from its return type, which measures AstValue +// first; AstObject, measured inside it, then sees T only in references to +// the types in progress, and main recorded it as independent of T and +// accepted the call. Main reports the error when AstObject's variance is +// measured first. + +export {}; + +type ObjectType = T extends object ? T : never; +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 12, 16)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 12, 16)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 12, 16)) + +class AstObject { +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + constructor(private host: E) {} +>host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + getObject(key: K): AstObject, E> { +>getObject : Symbol(AstObject.getObject, Decl(varianceCircularityEnteredByInference.ts, 15, 35)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 17, 14)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>key : Symbol(key, Decl(varianceCircularityEnteredByInference.ts, 17, 42)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 17, 14)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + return new AstObject, E>(this.host); +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) +>this.host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) +>this : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) + } + + getValue(key: K): AstValue { +>getValue : Symbol(AstObject.getValue, Decl(varianceCircularityEnteredByInference.ts, 19, 5)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 21, 13)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>key : Symbol(key, Decl(varianceCircularityEnteredByInference.ts, 21, 41)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 21, 13)) +>AstValue : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 14, 16)) +>K : Symbol(K, Decl(varianceCircularityEnteredByInference.ts, 21, 13)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 14, 33)) + + return new AstValue(this.host); +>AstValue : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>this.host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) +>this : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>host : Symbol(AstObject.host, Decl(varianceCircularityEnteredByInference.ts, 15, 16)) + } +} + +class AstValue { +>AstValue : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 26, 15)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 26, 17)) + + declare typeBrand: T; +>typeBrand : Symbol(AstValue.typeBrand, Decl(varianceCircularityEnteredByInference.ts, 26, 22)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 26, 15)) + + constructor(private host: E) {} +>host : Symbol(AstValue.host, Decl(varianceCircularityEnteredByInference.ts, 29, 16)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 26, 17)) + + getObject(): AstObject, E> { +>getObject : Symbol(AstValue.getObject, Decl(varianceCircularityEnteredByInference.ts, 29, 35)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>ObjectType : Symbol(ObjectType, Decl(varianceCircularityEnteredByInference.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCircularityEnteredByInference.ts, 26, 15)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 26, 17)) + + return new AstObject(this.host); +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>this.host : Symbol(AstValue.host, Decl(varianceCircularityEnteredByInference.ts, 29, 16)) +>this : Symbol(AstValue, Decl(varianceCircularityEnteredByInference.ts, 24, 1)) +>host : Symbol(AstValue.host, Decl(varianceCircularityEnteredByInference.ts, 29, 16)) + } +} + +interface Empty {} +>Empty : Symbol(Empty, Decl(varianceCircularityEnteredByInference.ts, 34, 1)) + +interface WithDecorators { +>WithDecorators : Symbol(WithDecorators, Decl(varianceCircularityEnteredByInference.ts, 36, 18)) + + decorators: string; +>decorators : Symbol(WithDecorators.decorators, Decl(varianceCircularityEnteredByInference.ts, 37, 26)) +} + +declare function useDerived(obj: AstObject): void; +>useDerived : Symbol(useDerived, Decl(varianceCircularityEnteredByInference.ts, 39, 1)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 41, 28)) +>obj : Symbol(obj, Decl(varianceCircularityEnteredByInference.ts, 41, 31)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>WithDecorators : Symbol(WithDecorators, Decl(varianceCircularityEnteredByInference.ts, 36, 18)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 41, 28)) + +function useBase(obj: AstObject) { +>useBase : Symbol(useBase, Decl(varianceCircularityEnteredByInference.ts, 41, 72)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 43, 17)) +>obj : Symbol(obj, Decl(varianceCircularityEnteredByInference.ts, 43, 20)) +>AstObject : Symbol(AstObject, Decl(varianceCircularityEnteredByInference.ts, 12, 50)) +>Empty : Symbol(Empty, Decl(varianceCircularityEnteredByInference.ts, 34, 1)) +>E : Symbol(E, Decl(varianceCircularityEnteredByInference.ts, 43, 17)) + + useDerived(obj); +>useDerived : Symbol(useDerived, Decl(varianceCircularityEnteredByInference.ts, 39, 1)) +>obj : Symbol(obj, Decl(varianceCircularityEnteredByInference.ts, 43, 20)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).types new file mode 100644 index 0000000000000..264ad82ecb3f7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).types @@ -0,0 +1,90 @@ +//// [tests/cases/compiler/varianceCircularityEnteredByInference.ts] //// + +=== varianceCircularityEnteredByInference.ts === +// AstObject and AstValue form a variance circularity. AstValue is covariant +// in T through typeBrand, and AstObject reaches it through getValue, so +// AstObject is not assignable to AstObject and the +// call below must be an error. Checking getValue first infers the type +// arguments of `new AstValue` from its return type, which measures AstValue +// first; AstObject, measured inside it, then sees T only in references to +// the types in progress, and main recorded it as independent of T and +// accepted the call. Main reports the error when AstObject's variance is +// measured first. + +export {}; + +type ObjectType = T extends object ? T : never; +>ObjectType : ObjectType + +class AstObject { +>AstObject : AstObject + + constructor(private host: E) {} +>host : E + + getObject(key: K): AstObject, E> { +>getObject : (key: K) => AstObject, E> +>key : K + + return new AstObject, E>(this.host); +>new AstObject, E>(this.host) : AstObject, E> +>AstObject : typeof AstObject +>this.host : E +>this : this +>host : E + } + + getValue(key: K): AstValue { +>getValue : (key: K) => AstValue +>key : K + + return new AstValue(this.host); +>new AstValue(this.host) : AstValue +>AstValue : typeof AstValue +>this.host : E +>this : this +>host : E + } +} + +class AstValue { +>AstValue : AstValue + + declare typeBrand: T; +>typeBrand : T + + constructor(private host: E) {} +>host : E + + getObject(): AstObject, E> { +>getObject : () => AstObject, E> + + return new AstObject(this.host); +>new AstObject(this.host) : AstObject, E> +>AstObject : typeof AstObject +>this.host : E +>this : this +>host : E + } +} + +interface Empty {} +interface WithDecorators { + decorators: string; +>decorators : string +} + +declare function useDerived(obj: AstObject): void; +>useDerived : (obj: AstObject) => void +>obj : AstObject + +function useBase(obj: AstObject) { +>useBase : (obj: AstObject) => void +>obj : AstObject + + useDerived(obj); +>useDerived(obj) : void +>useDerived : (obj: AstObject) => void +>obj : AstObject +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).errors.txt new file mode 100644 index 0000000000000..ded3dbea54a67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).errors.txt @@ -0,0 +1,141 @@ +varianceCircularityHidesInvariance.ts(69,37): error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. + Types of parameters 'chart' and 'chart' are incompatible. + Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. + The types of 'config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. + Types of property 'tooltip' are incompatible. + Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. + Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. + Types of property 'callbacks' are incompatible. + Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. + Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. + Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. + The types of 'chart.config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. + Types of property 'data' are incompatible. + Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. + Type '"line"' is not assignable to type '"bar"'. + + +==== varianceCircularityHidesInvariance.ts (1 errors) ==== + // Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and + // ScriptableContext form a variance circularity. ScriptableContext is in + // fact invariant: ScriptableContext<"bar" | "line"> is not assignable to + // ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not + // assignable to Chart and the assignment below must be an error. + // Measuring variances from the circularity's entry, main recorded + // ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and + // accepted it; main reports this error too when ScriptableContext's variance + // is measured first (e.g. after checking a ScriptableContext assignment). + + declare class Element { options: O } + type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined + type _DeepPartialObject = { [P in keyof T]?: DeepPartial } + type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never + type AnyObject = Record + interface ScriptableContext { + dataset: UnionToIntersection> + } + type Scriptable = (ctx: TContext) => T + declare class Chart { + config: ChartConfigurationCustomTypesPerDataset + } + interface Plugin { + id: string; + beforeDraw(chart: Chart): void + } + interface CoreChartOptions { + backgroundColor: Scriptable> + } + interface AnimationSpec { + delay: Scriptable> + } + interface TooltipModel extends Element> { + chart: Chart + } + interface TooltipDatasetCallbacks> { + (this: Model): void + } + interface TooltipOptions { + animation: AnimationSpec + } + interface TooltipDatasetOptions { + callbacks: TooltipDatasetCallbacks + } + interface PluginDatasetOptionsByType { + tooltip: TooltipDatasetOptions + } + interface ChartTypeRegistry { + bar: { defaultDataPoint: [] } + line: { defaultDataPoint: null } + } + type ChartType = keyof ChartTypeRegistry + type DatasetChartOptions = { [key in TType]: {} } + type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> + interface ChartDatasetProperties { + data: TData + } + type ChartDataset = + DeepPartial> & ChartDatasetProperties + type ChartDatasetCustomTypesPerDataset = DeepPartial> + interface ChartDataCustomTypesPerDataset { + datasets: ChartDatasetCustomTypesPerDataset + } + export interface ChartConfigurationCustomTypesPerDataset { + data: ChartDataCustomTypesPerDataset + options: ChartOptions + } + + const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; + ~~~~~~~~~~ +!!! error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. +!!! error TS2322: Types of parameters 'chart' and 'chart' are incompatible. +!!! error TS2322: Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. +!!! error TS2322: The types of 'config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. +!!! error TS2322: Types of property 'tooltip' are incompatible. +!!! error TS2322: Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. +!!! error TS2322: Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. +!!! error TS2322: Types of property 'callbacks' are incompatible. +!!! error TS2322: Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. +!!! error TS2322: Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. +!!! error TS2322: Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. +!!! error TS2322: The types of 'chart.config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Types of property 'data' are incompatible. +!!! error TS2322: Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. +!!! error TS2322: Type '"line"' is not assignable to type '"bar"'. +!!! related TS6500 varianceCircularityHidesInvariance.ts:25:5: The expected type comes from property 'beforeDraw' which is declared here on type 'Plugin<"bar">' + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).symbols new file mode 100644 index 0000000000000..9d8fa95ef18da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).symbols @@ -0,0 +1,279 @@ +//// [tests/cases/compiler/varianceCircularityHidesInvariance.ts] //// + +=== varianceCircularityHidesInvariance.ts === +// Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and +// ScriptableContext form a variance circularity. ScriptableContext is in +// fact invariant: ScriptableContext<"bar" | "line"> is not assignable to +// ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not +// assignable to Chart and the assignment below must be an error. +// Measuring variances from the circularity's entry, main recorded +// ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and +// accepted it; main reports this error too when ScriptableContext's variance +// is measured first (e.g. after checking a ScriptableContext assignment). + +declare class Element { options: O } +>Element : Symbol(Element, Decl(varianceCircularityHidesInvariance.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 10, 22)) +>O : Symbol(O, Decl(varianceCircularityHidesInvariance.ts, 10, 24)) +>options : Symbol(Element.options, Decl(varianceCircularityHidesInvariance.ts, 10, 29)) +>O : Symbol(O, Decl(varianceCircularityHidesInvariance.ts, 10, 24)) + +type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>_DeepPartialObject : Symbol(_DeepPartialObject, Decl(varianceCircularityHidesInvariance.ts, 11, 99)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) + +type _DeepPartialObject = { [P in keyof T]?: DeepPartial } +>_DeepPartialObject : Symbol(_DeepPartialObject, Decl(varianceCircularityHidesInvariance.ts, 11, 99)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 12, 24)) +>P : Symbol(P, Decl(varianceCircularityHidesInvariance.ts, 12, 32)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 12, 24)) +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 12, 24)) +>P : Symbol(P, Decl(varianceCircularityHidesInvariance.ts, 12, 32)) + +type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never +>UnionToIntersection : Symbol(UnionToIntersection, Decl(varianceCircularityHidesInvariance.ts, 12, 67)) +>U : Symbol(U, Decl(varianceCircularityHidesInvariance.ts, 13, 25)) +>U : Symbol(U, Decl(varianceCircularityHidesInvariance.ts, 13, 25)) +>k : Symbol(k, Decl(varianceCircularityHidesInvariance.ts, 13, 52)) +>U : Symbol(U, Decl(varianceCircularityHidesInvariance.ts, 13, 25)) +>k : Symbol(k, Decl(varianceCircularityHidesInvariance.ts, 13, 84)) +>I : Symbol(I, Decl(varianceCircularityHidesInvariance.ts, 13, 92)) +>I : Symbol(I, Decl(varianceCircularityHidesInvariance.ts, 13, 92)) + +type AnyObject = Record +>AnyObject : Symbol(AnyObject, Decl(varianceCircularityHidesInvariance.ts, 13, 115)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +interface ScriptableContext { +>ScriptableContext : Symbol(ScriptableContext, Decl(varianceCircularityHidesInvariance.ts, 14, 36)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 15, 28)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + dataset: UnionToIntersection> +>dataset : Symbol(ScriptableContext.dataset, Decl(varianceCircularityHidesInvariance.ts, 15, 54)) +>UnionToIntersection : Symbol(UnionToIntersection, Decl(varianceCircularityHidesInvariance.ts, 12, 67)) +>ChartDataset : Symbol(ChartDataset, Decl(varianceCircularityHidesInvariance.ts, 56, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 15, 28)) +} +type Scriptable = (ctx: TContext) => T +>Scriptable : Symbol(Scriptable, Decl(varianceCircularityHidesInvariance.ts, 17, 1)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 18, 16)) +>TContext : Symbol(TContext, Decl(varianceCircularityHidesInvariance.ts, 18, 18)) +>ctx : Symbol(ctx, Decl(varianceCircularityHidesInvariance.ts, 18, 32)) +>TContext : Symbol(TContext, Decl(varianceCircularityHidesInvariance.ts, 18, 18)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 18, 16)) + +declare class Chart { +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 19, 20)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 19, 56)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 19, 20)) + + config: ChartConfigurationCustomTypesPerDataset +>config : Symbol(Chart.config, Decl(varianceCircularityHidesInvariance.ts, 19, 73)) +>ChartConfigurationCustomTypesPerDataset : Symbol(ChartConfigurationCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 62, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 19, 20)) +} +interface Plugin { +>Plugin : Symbol(Plugin, Decl(varianceCircularityHidesInvariance.ts, 21, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 22, 17)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + id: string; +>id : Symbol(Plugin.id, Decl(varianceCircularityHidesInvariance.ts, 22, 43)) + + beforeDraw(chart: Chart): void +>beforeDraw : Symbol(Plugin.beforeDraw, Decl(varianceCircularityHidesInvariance.ts, 23, 15)) +>chart : Symbol(chart, Decl(varianceCircularityHidesInvariance.ts, 24, 15)) +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 22, 17)) +} +interface CoreChartOptions { +>CoreChartOptions : Symbol(CoreChartOptions, Decl(varianceCircularityHidesInvariance.ts, 25, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 26, 27)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + backgroundColor: Scriptable> +>backgroundColor : Symbol(CoreChartOptions.backgroundColor, Decl(varianceCircularityHidesInvariance.ts, 26, 53)) +>Scriptable : Symbol(Scriptable, Decl(varianceCircularityHidesInvariance.ts, 17, 1)) +>ScriptableContext : Symbol(ScriptableContext, Decl(varianceCircularityHidesInvariance.ts, 14, 36)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 26, 27)) +} +interface AnimationSpec { +>AnimationSpec : Symbol(AnimationSpec, Decl(varianceCircularityHidesInvariance.ts, 28, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 29, 24)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + delay: Scriptable> +>delay : Symbol(AnimationSpec.delay, Decl(varianceCircularityHidesInvariance.ts, 29, 50)) +>Scriptable : Symbol(Scriptable, Decl(varianceCircularityHidesInvariance.ts, 17, 1)) +>ScriptableContext : Symbol(ScriptableContext, Decl(varianceCircularityHidesInvariance.ts, 14, 36)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 29, 24)) +} +interface TooltipModel extends Element> { +>TooltipModel : Symbol(TooltipModel, Decl(varianceCircularityHidesInvariance.ts, 31, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 32, 23)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>Element : Symbol(Element, Decl(varianceCircularityHidesInvariance.ts, 0, 0)) +>AnyObject : Symbol(AnyObject, Decl(varianceCircularityHidesInvariance.ts, 13, 115)) +>TooltipOptions : Symbol(TooltipOptions, Decl(varianceCircularityHidesInvariance.ts, 37, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 32, 23)) + + chart: Chart +>chart : Symbol(TooltipModel.chart, Decl(varianceCircularityHidesInvariance.ts, 32, 99)) +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 32, 23)) +} +interface TooltipDatasetCallbacks> { +>TooltipDatasetCallbacks : Symbol(TooltipDatasetCallbacks, Decl(varianceCircularityHidesInvariance.ts, 34, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 35, 34)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>Model : Symbol(Model, Decl(varianceCircularityHidesInvariance.ts, 35, 58)) +>TooltipModel : Symbol(TooltipModel, Decl(varianceCircularityHidesInvariance.ts, 31, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 35, 34)) + + (this: Model): void +>this : Symbol(this, Decl(varianceCircularityHidesInvariance.ts, 36, 5)) +>Model : Symbol(Model, Decl(varianceCircularityHidesInvariance.ts, 35, 58)) +} +interface TooltipOptions { +>TooltipOptions : Symbol(TooltipOptions, Decl(varianceCircularityHidesInvariance.ts, 37, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 38, 25)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + animation: AnimationSpec +>animation : Symbol(TooltipOptions.animation, Decl(varianceCircularityHidesInvariance.ts, 38, 51)) +>AnimationSpec : Symbol(AnimationSpec, Decl(varianceCircularityHidesInvariance.ts, 28, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 38, 25)) +} +interface TooltipDatasetOptions { +>TooltipDatasetOptions : Symbol(TooltipDatasetOptions, Decl(varianceCircularityHidesInvariance.ts, 40, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 41, 32)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + callbacks: TooltipDatasetCallbacks +>callbacks : Symbol(TooltipDatasetOptions.callbacks, Decl(varianceCircularityHidesInvariance.ts, 41, 58)) +>TooltipDatasetCallbacks : Symbol(TooltipDatasetCallbacks, Decl(varianceCircularityHidesInvariance.ts, 34, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 41, 32)) +} +interface PluginDatasetOptionsByType { +>PluginDatasetOptionsByType : Symbol(PluginDatasetOptionsByType, Decl(varianceCircularityHidesInvariance.ts, 43, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 44, 37)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + tooltip: TooltipDatasetOptions +>tooltip : Symbol(PluginDatasetOptionsByType.tooltip, Decl(varianceCircularityHidesInvariance.ts, 44, 63)) +>TooltipDatasetOptions : Symbol(TooltipDatasetOptions, Decl(varianceCircularityHidesInvariance.ts, 40, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 44, 37)) +} +interface ChartTypeRegistry { +>ChartTypeRegistry : Symbol(ChartTypeRegistry, Decl(varianceCircularityHidesInvariance.ts, 46, 1)) + + bar: { defaultDataPoint: [] } +>bar : Symbol(ChartTypeRegistry.bar, Decl(varianceCircularityHidesInvariance.ts, 47, 29)) +>defaultDataPoint : Symbol(defaultDataPoint, Decl(varianceCircularityHidesInvariance.ts, 48, 10)) + + line: { defaultDataPoint: null } +>line : Symbol(ChartTypeRegistry.line, Decl(varianceCircularityHidesInvariance.ts, 48, 33)) +>defaultDataPoint : Symbol(defaultDataPoint, Decl(varianceCircularityHidesInvariance.ts, 49, 11)) +} +type ChartType = keyof ChartTypeRegistry +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>ChartTypeRegistry : Symbol(ChartTypeRegistry, Decl(varianceCircularityHidesInvariance.ts, 46, 1)) + +type DatasetChartOptions = { [key in TType]: {} } +>DatasetChartOptions : Symbol(DatasetChartOptions, Decl(varianceCircularityHidesInvariance.ts, 51, 40)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 52, 25)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>key : Symbol(key, Decl(varianceCircularityHidesInvariance.ts, 52, 55)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 52, 25)) + +type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> +>ChartOptions : Symbol(ChartOptions, Decl(varianceCircularityHidesInvariance.ts, 52, 74)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>CoreChartOptions : Symbol(CoreChartOptions, Decl(varianceCircularityHidesInvariance.ts, 25, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) +>DatasetChartOptions : Symbol(DatasetChartOptions, Decl(varianceCircularityHidesInvariance.ts, 51, 40)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) + +interface ChartDatasetProperties { +>ChartDatasetProperties : Symbol(ChartDatasetProperties, Decl(varianceCircularityHidesInvariance.ts, 53, 138)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 54, 33)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 54, 39)) + + data: TData +>data : Symbol(ChartDatasetProperties.data, Decl(varianceCircularityHidesInvariance.ts, 54, 48)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 54, 39)) +} +type ChartDataset = +>ChartDataset : Symbol(ChartDataset, Decl(varianceCircularityHidesInvariance.ts, 56, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 57, 42)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) + + DeepPartial> & ChartDatasetProperties +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>ChartTypeRegistry : Symbol(ChartTypeRegistry, Decl(varianceCircularityHidesInvariance.ts, 46, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>PluginDatasetOptionsByType : Symbol(PluginDatasetOptionsByType, Decl(varianceCircularityHidesInvariance.ts, 43, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>ChartDatasetProperties : Symbol(ChartDatasetProperties, Decl(varianceCircularityHidesInvariance.ts, 53, 138)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 57, 42)) + +type ChartDatasetCustomTypesPerDataset = DeepPartial> +>ChartDatasetCustomTypesPerDataset : Symbol(ChartDatasetCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 58, 116)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 59, 39)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>PluginDatasetOptionsByType : Symbol(PluginDatasetOptionsByType, Decl(varianceCircularityHidesInvariance.ts, 43, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 59, 39)) + +interface ChartDataCustomTypesPerDataset { +>ChartDataCustomTypesPerDataset : Symbol(ChartDataCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 59, 112)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 60, 41)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + datasets: ChartDatasetCustomTypesPerDataset +>datasets : Symbol(ChartDataCustomTypesPerDataset.datasets, Decl(varianceCircularityHidesInvariance.ts, 60, 67)) +>ChartDatasetCustomTypesPerDataset : Symbol(ChartDatasetCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 58, 116)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 60, 41)) +} +export interface ChartConfigurationCustomTypesPerDataset { +>ChartConfigurationCustomTypesPerDataset : Symbol(ChartConfigurationCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 62, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 63, 57)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + data: ChartDataCustomTypesPerDataset +>data : Symbol(ChartConfigurationCustomTypesPerDataset.data, Decl(varianceCircularityHidesInvariance.ts, 63, 83)) +>ChartDataCustomTypesPerDataset : Symbol(ChartDataCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 59, 112)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 63, 57)) + + options: ChartOptions +>options : Symbol(ChartConfigurationCustomTypesPerDataset.options, Decl(varianceCircularityHidesInvariance.ts, 64, 47)) +>ChartOptions : Symbol(ChartOptions, Decl(varianceCircularityHidesInvariance.ts, 52, 74)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 63, 57)) +} + +const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; +>p : Symbol(p, Decl(varianceCircularityHidesInvariance.ts, 68, 5)) +>Plugin : Symbol(Plugin, Decl(varianceCircularityHidesInvariance.ts, 21, 1)) +>id : Symbol(id, Decl(varianceCircularityHidesInvariance.ts, 68, 26)) +>beforeDraw : Symbol(beforeDraw, Decl(varianceCircularityHidesInvariance.ts, 68, 35)) +>chart : Symbol(chart, Decl(varianceCircularityHidesInvariance.ts, 68, 49)) +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).types new file mode 100644 index 0000000000000..78c2a7fbee0a8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).types @@ -0,0 +1,131 @@ +//// [tests/cases/compiler/varianceCircularityHidesInvariance.ts] //// + +=== varianceCircularityHidesInvariance.ts === +// Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and +// ScriptableContext form a variance circularity. ScriptableContext is in +// fact invariant: ScriptableContext<"bar" | "line"> is not assignable to +// ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not +// assignable to Chart and the assignment below must be an error. +// Measuring variances from the circularity's entry, main recorded +// ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and +// accepted it; main reports this error too when ScriptableContext's variance +// is measured first (e.g. after checking a ScriptableContext assignment). + +declare class Element { options: O } +>Element : Element +>options : O + +type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined +>DeepPartial : DeepPartial + +type _DeepPartialObject = { [P in keyof T]?: DeepPartial } +>_DeepPartialObject : _DeepPartialObject + +type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never +>UnionToIntersection : UnionToIntersection +>k : U +>k : I + +type AnyObject = Record +>AnyObject : AnyObject + +interface ScriptableContext { + dataset: UnionToIntersection> +>dataset : UnionToIntersection> +} +type Scriptable = (ctx: TContext) => T +>Scriptable : Scriptable +>ctx : TContext + +declare class Chart { +>Chart : Chart + + config: ChartConfigurationCustomTypesPerDataset +>config : ChartConfigurationCustomTypesPerDataset +} +interface Plugin { + id: string; +>id : string + + beforeDraw(chart: Chart): void +>beforeDraw : (chart: Chart) => void +>chart : Chart +} +interface CoreChartOptions { + backgroundColor: Scriptable> +>backgroundColor : Scriptable> +} +interface AnimationSpec { + delay: Scriptable> +>delay : Scriptable> +} +interface TooltipModel extends Element> { + chart: Chart +>chart : Chart +} +interface TooltipDatasetCallbacks> { + (this: Model): void +>this : Model +} +interface TooltipOptions { + animation: AnimationSpec +>animation : AnimationSpec +} +interface TooltipDatasetOptions { + callbacks: TooltipDatasetCallbacks +>callbacks : TooltipDatasetCallbacks> +} +interface PluginDatasetOptionsByType { + tooltip: TooltipDatasetOptions +>tooltip : TooltipDatasetOptions +} +interface ChartTypeRegistry { + bar: { defaultDataPoint: [] } +>bar : { defaultDataPoint: []; } +>defaultDataPoint : [] + + line: { defaultDataPoint: null } +>line : { defaultDataPoint: null; } +>defaultDataPoint : null +} +type ChartType = keyof ChartTypeRegistry +>ChartType : keyof ChartTypeRegistry + +type DatasetChartOptions = { [key in TType]: {} } +>DatasetChartOptions : DatasetChartOptions + +type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> +>ChartOptions : ChartOptions + +interface ChartDatasetProperties { + data: TData +>data : TData +} +type ChartDataset = +>ChartDataset : ChartDataset + + DeepPartial> & ChartDatasetProperties +type ChartDatasetCustomTypesPerDataset = DeepPartial> +>ChartDatasetCustomTypesPerDataset : _DeepPartialObject> + +interface ChartDataCustomTypesPerDataset { + datasets: ChartDatasetCustomTypesPerDataset +>datasets : _DeepPartialObject> +} +export interface ChartConfigurationCustomTypesPerDataset { + data: ChartDataCustomTypesPerDataset +>data : ChartDataCustomTypesPerDataset + + options: ChartOptions +>options : Exclude & DatasetChartOptions & TType>, undefined> +} + +const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; +>p : Plugin<"bar"> +>{ id: "x", beforeDraw: (chart: Chart) => {} } : { id: string; beforeDraw: (chart: Chart) => void; } +>id : string +>"x" : "x" +>beforeDraw : (chart: Chart) => void +>(chart: Chart) => {} : (chart: Chart) => void +>chart : Chart + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..ded3dbea54a67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).errors.txt @@ -0,0 +1,141 @@ +varianceCircularityHidesInvariance.ts(69,37): error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. + Types of parameters 'chart' and 'chart' are incompatible. + Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. + The types of 'config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. + Types of property 'tooltip' are incompatible. + Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. + Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. + Types of property 'callbacks' are incompatible. + Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. + Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. + Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. + The types of 'chart.config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. + Types of property 'data' are incompatible. + Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. + Type '"line"' is not assignable to type '"bar"'. + + +==== varianceCircularityHidesInvariance.ts (1 errors) ==== + // Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and + // ScriptableContext form a variance circularity. ScriptableContext is in + // fact invariant: ScriptableContext<"bar" | "line"> is not assignable to + // ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not + // assignable to Chart and the assignment below must be an error. + // Measuring variances from the circularity's entry, main recorded + // ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and + // accepted it; main reports this error too when ScriptableContext's variance + // is measured first (e.g. after checking a ScriptableContext assignment). + + declare class Element { options: O } + type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined + type _DeepPartialObject = { [P in keyof T]?: DeepPartial } + type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never + type AnyObject = Record + interface ScriptableContext { + dataset: UnionToIntersection> + } + type Scriptable = (ctx: TContext) => T + declare class Chart { + config: ChartConfigurationCustomTypesPerDataset + } + interface Plugin { + id: string; + beforeDraw(chart: Chart): void + } + interface CoreChartOptions { + backgroundColor: Scriptable> + } + interface AnimationSpec { + delay: Scriptable> + } + interface TooltipModel extends Element> { + chart: Chart + } + interface TooltipDatasetCallbacks> { + (this: Model): void + } + interface TooltipOptions { + animation: AnimationSpec + } + interface TooltipDatasetOptions { + callbacks: TooltipDatasetCallbacks + } + interface PluginDatasetOptionsByType { + tooltip: TooltipDatasetOptions + } + interface ChartTypeRegistry { + bar: { defaultDataPoint: [] } + line: { defaultDataPoint: null } + } + type ChartType = keyof ChartTypeRegistry + type DatasetChartOptions = { [key in TType]: {} } + type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> + interface ChartDatasetProperties { + data: TData + } + type ChartDataset = + DeepPartial> & ChartDatasetProperties + type ChartDatasetCustomTypesPerDataset = DeepPartial> + interface ChartDataCustomTypesPerDataset { + datasets: ChartDatasetCustomTypesPerDataset + } + export interface ChartConfigurationCustomTypesPerDataset { + data: ChartDataCustomTypesPerDataset + options: ChartOptions + } + + const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; + ~~~~~~~~~~ +!!! error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. +!!! error TS2322: Types of parameters 'chart' and 'chart' are incompatible. +!!! error TS2322: Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. +!!! error TS2322: The types of 'config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. +!!! error TS2322: Types of property 'tooltip' are incompatible. +!!! error TS2322: Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. +!!! error TS2322: Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. +!!! error TS2322: Types of property 'callbacks' are incompatible. +!!! error TS2322: Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. +!!! error TS2322: Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. +!!! error TS2322: Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. +!!! error TS2322: The types of 'chart.config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Types of property 'data' are incompatible. +!!! error TS2322: Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. +!!! error TS2322: Type '"line"' is not assignable to type '"bar"'. +!!! related TS6500 varianceCircularityHidesInvariance.ts:25:5: The expected type comes from property 'beforeDraw' which is declared here on type 'Plugin<"bar">' + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..9d8fa95ef18da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).symbols @@ -0,0 +1,279 @@ +//// [tests/cases/compiler/varianceCircularityHidesInvariance.ts] //// + +=== varianceCircularityHidesInvariance.ts === +// Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and +// ScriptableContext form a variance circularity. ScriptableContext is in +// fact invariant: ScriptableContext<"bar" | "line"> is not assignable to +// ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not +// assignable to Chart and the assignment below must be an error. +// Measuring variances from the circularity's entry, main recorded +// ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and +// accepted it; main reports this error too when ScriptableContext's variance +// is measured first (e.g. after checking a ScriptableContext assignment). + +declare class Element { options: O } +>Element : Symbol(Element, Decl(varianceCircularityHidesInvariance.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 10, 22)) +>O : Symbol(O, Decl(varianceCircularityHidesInvariance.ts, 10, 24)) +>options : Symbol(Element.options, Decl(varianceCircularityHidesInvariance.ts, 10, 29)) +>O : Symbol(O, Decl(varianceCircularityHidesInvariance.ts, 10, 24)) + +type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) +>_DeepPartialObject : Symbol(_DeepPartialObject, Decl(varianceCircularityHidesInvariance.ts, 11, 99)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 11, 17)) + +type _DeepPartialObject = { [P in keyof T]?: DeepPartial } +>_DeepPartialObject : Symbol(_DeepPartialObject, Decl(varianceCircularityHidesInvariance.ts, 11, 99)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 12, 24)) +>P : Symbol(P, Decl(varianceCircularityHidesInvariance.ts, 12, 32)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 12, 24)) +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 12, 24)) +>P : Symbol(P, Decl(varianceCircularityHidesInvariance.ts, 12, 32)) + +type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never +>UnionToIntersection : Symbol(UnionToIntersection, Decl(varianceCircularityHidesInvariance.ts, 12, 67)) +>U : Symbol(U, Decl(varianceCircularityHidesInvariance.ts, 13, 25)) +>U : Symbol(U, Decl(varianceCircularityHidesInvariance.ts, 13, 25)) +>k : Symbol(k, Decl(varianceCircularityHidesInvariance.ts, 13, 52)) +>U : Symbol(U, Decl(varianceCircularityHidesInvariance.ts, 13, 25)) +>k : Symbol(k, Decl(varianceCircularityHidesInvariance.ts, 13, 84)) +>I : Symbol(I, Decl(varianceCircularityHidesInvariance.ts, 13, 92)) +>I : Symbol(I, Decl(varianceCircularityHidesInvariance.ts, 13, 92)) + +type AnyObject = Record +>AnyObject : Symbol(AnyObject, Decl(varianceCircularityHidesInvariance.ts, 13, 115)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +interface ScriptableContext { +>ScriptableContext : Symbol(ScriptableContext, Decl(varianceCircularityHidesInvariance.ts, 14, 36)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 15, 28)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + dataset: UnionToIntersection> +>dataset : Symbol(ScriptableContext.dataset, Decl(varianceCircularityHidesInvariance.ts, 15, 54)) +>UnionToIntersection : Symbol(UnionToIntersection, Decl(varianceCircularityHidesInvariance.ts, 12, 67)) +>ChartDataset : Symbol(ChartDataset, Decl(varianceCircularityHidesInvariance.ts, 56, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 15, 28)) +} +type Scriptable = (ctx: TContext) => T +>Scriptable : Symbol(Scriptable, Decl(varianceCircularityHidesInvariance.ts, 17, 1)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 18, 16)) +>TContext : Symbol(TContext, Decl(varianceCircularityHidesInvariance.ts, 18, 18)) +>ctx : Symbol(ctx, Decl(varianceCircularityHidesInvariance.ts, 18, 32)) +>TContext : Symbol(TContext, Decl(varianceCircularityHidesInvariance.ts, 18, 18)) +>T : Symbol(T, Decl(varianceCircularityHidesInvariance.ts, 18, 16)) + +declare class Chart { +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 19, 20)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 19, 56)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 19, 20)) + + config: ChartConfigurationCustomTypesPerDataset +>config : Symbol(Chart.config, Decl(varianceCircularityHidesInvariance.ts, 19, 73)) +>ChartConfigurationCustomTypesPerDataset : Symbol(ChartConfigurationCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 62, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 19, 20)) +} +interface Plugin { +>Plugin : Symbol(Plugin, Decl(varianceCircularityHidesInvariance.ts, 21, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 22, 17)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + id: string; +>id : Symbol(Plugin.id, Decl(varianceCircularityHidesInvariance.ts, 22, 43)) + + beforeDraw(chart: Chart): void +>beforeDraw : Symbol(Plugin.beforeDraw, Decl(varianceCircularityHidesInvariance.ts, 23, 15)) +>chart : Symbol(chart, Decl(varianceCircularityHidesInvariance.ts, 24, 15)) +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 22, 17)) +} +interface CoreChartOptions { +>CoreChartOptions : Symbol(CoreChartOptions, Decl(varianceCircularityHidesInvariance.ts, 25, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 26, 27)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + backgroundColor: Scriptable> +>backgroundColor : Symbol(CoreChartOptions.backgroundColor, Decl(varianceCircularityHidesInvariance.ts, 26, 53)) +>Scriptable : Symbol(Scriptable, Decl(varianceCircularityHidesInvariance.ts, 17, 1)) +>ScriptableContext : Symbol(ScriptableContext, Decl(varianceCircularityHidesInvariance.ts, 14, 36)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 26, 27)) +} +interface AnimationSpec { +>AnimationSpec : Symbol(AnimationSpec, Decl(varianceCircularityHidesInvariance.ts, 28, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 29, 24)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + delay: Scriptable> +>delay : Symbol(AnimationSpec.delay, Decl(varianceCircularityHidesInvariance.ts, 29, 50)) +>Scriptable : Symbol(Scriptable, Decl(varianceCircularityHidesInvariance.ts, 17, 1)) +>ScriptableContext : Symbol(ScriptableContext, Decl(varianceCircularityHidesInvariance.ts, 14, 36)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 29, 24)) +} +interface TooltipModel extends Element> { +>TooltipModel : Symbol(TooltipModel, Decl(varianceCircularityHidesInvariance.ts, 31, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 32, 23)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>Element : Symbol(Element, Decl(varianceCircularityHidesInvariance.ts, 0, 0)) +>AnyObject : Symbol(AnyObject, Decl(varianceCircularityHidesInvariance.ts, 13, 115)) +>TooltipOptions : Symbol(TooltipOptions, Decl(varianceCircularityHidesInvariance.ts, 37, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 32, 23)) + + chart: Chart +>chart : Symbol(TooltipModel.chart, Decl(varianceCircularityHidesInvariance.ts, 32, 99)) +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 32, 23)) +} +interface TooltipDatasetCallbacks> { +>TooltipDatasetCallbacks : Symbol(TooltipDatasetCallbacks, Decl(varianceCircularityHidesInvariance.ts, 34, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 35, 34)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>Model : Symbol(Model, Decl(varianceCircularityHidesInvariance.ts, 35, 58)) +>TooltipModel : Symbol(TooltipModel, Decl(varianceCircularityHidesInvariance.ts, 31, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 35, 34)) + + (this: Model): void +>this : Symbol(this, Decl(varianceCircularityHidesInvariance.ts, 36, 5)) +>Model : Symbol(Model, Decl(varianceCircularityHidesInvariance.ts, 35, 58)) +} +interface TooltipOptions { +>TooltipOptions : Symbol(TooltipOptions, Decl(varianceCircularityHidesInvariance.ts, 37, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 38, 25)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + animation: AnimationSpec +>animation : Symbol(TooltipOptions.animation, Decl(varianceCircularityHidesInvariance.ts, 38, 51)) +>AnimationSpec : Symbol(AnimationSpec, Decl(varianceCircularityHidesInvariance.ts, 28, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 38, 25)) +} +interface TooltipDatasetOptions { +>TooltipDatasetOptions : Symbol(TooltipDatasetOptions, Decl(varianceCircularityHidesInvariance.ts, 40, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 41, 32)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + callbacks: TooltipDatasetCallbacks +>callbacks : Symbol(TooltipDatasetOptions.callbacks, Decl(varianceCircularityHidesInvariance.ts, 41, 58)) +>TooltipDatasetCallbacks : Symbol(TooltipDatasetCallbacks, Decl(varianceCircularityHidesInvariance.ts, 34, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 41, 32)) +} +interface PluginDatasetOptionsByType { +>PluginDatasetOptionsByType : Symbol(PluginDatasetOptionsByType, Decl(varianceCircularityHidesInvariance.ts, 43, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 44, 37)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + tooltip: TooltipDatasetOptions +>tooltip : Symbol(PluginDatasetOptionsByType.tooltip, Decl(varianceCircularityHidesInvariance.ts, 44, 63)) +>TooltipDatasetOptions : Symbol(TooltipDatasetOptions, Decl(varianceCircularityHidesInvariance.ts, 40, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 44, 37)) +} +interface ChartTypeRegistry { +>ChartTypeRegistry : Symbol(ChartTypeRegistry, Decl(varianceCircularityHidesInvariance.ts, 46, 1)) + + bar: { defaultDataPoint: [] } +>bar : Symbol(ChartTypeRegistry.bar, Decl(varianceCircularityHidesInvariance.ts, 47, 29)) +>defaultDataPoint : Symbol(defaultDataPoint, Decl(varianceCircularityHidesInvariance.ts, 48, 10)) + + line: { defaultDataPoint: null } +>line : Symbol(ChartTypeRegistry.line, Decl(varianceCircularityHidesInvariance.ts, 48, 33)) +>defaultDataPoint : Symbol(defaultDataPoint, Decl(varianceCircularityHidesInvariance.ts, 49, 11)) +} +type ChartType = keyof ChartTypeRegistry +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>ChartTypeRegistry : Symbol(ChartTypeRegistry, Decl(varianceCircularityHidesInvariance.ts, 46, 1)) + +type DatasetChartOptions = { [key in TType]: {} } +>DatasetChartOptions : Symbol(DatasetChartOptions, Decl(varianceCircularityHidesInvariance.ts, 51, 40)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 52, 25)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>key : Symbol(key, Decl(varianceCircularityHidesInvariance.ts, 52, 55)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 52, 25)) + +type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> +>ChartOptions : Symbol(ChartOptions, Decl(varianceCircularityHidesInvariance.ts, 52, 74)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>CoreChartOptions : Symbol(CoreChartOptions, Decl(varianceCircularityHidesInvariance.ts, 25, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) +>DatasetChartOptions : Symbol(DatasetChartOptions, Decl(varianceCircularityHidesInvariance.ts, 51, 40)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 53, 18)) + +interface ChartDatasetProperties { +>ChartDatasetProperties : Symbol(ChartDatasetProperties, Decl(varianceCircularityHidesInvariance.ts, 53, 138)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 54, 33)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 54, 39)) + + data: TData +>data : Symbol(ChartDatasetProperties.data, Decl(varianceCircularityHidesInvariance.ts, 54, 48)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 54, 39)) +} +type ChartDataset = +>ChartDataset : Symbol(ChartDataset, Decl(varianceCircularityHidesInvariance.ts, 56, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 57, 42)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) + + DeepPartial> & ChartDatasetProperties +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>ChartTypeRegistry : Symbol(ChartTypeRegistry, Decl(varianceCircularityHidesInvariance.ts, 46, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>PluginDatasetOptionsByType : Symbol(PluginDatasetOptionsByType, Decl(varianceCircularityHidesInvariance.ts, 43, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>ChartDatasetProperties : Symbol(ChartDatasetProperties, Decl(varianceCircularityHidesInvariance.ts, 53, 138)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 57, 18)) +>TData : Symbol(TData, Decl(varianceCircularityHidesInvariance.ts, 57, 42)) + +type ChartDatasetCustomTypesPerDataset = DeepPartial> +>ChartDatasetCustomTypesPerDataset : Symbol(ChartDatasetCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 58, 116)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 59, 39)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) +>DeepPartial : Symbol(DeepPartial, Decl(varianceCircularityHidesInvariance.ts, 10, 42)) +>PluginDatasetOptionsByType : Symbol(PluginDatasetOptionsByType, Decl(varianceCircularityHidesInvariance.ts, 43, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 59, 39)) + +interface ChartDataCustomTypesPerDataset { +>ChartDataCustomTypesPerDataset : Symbol(ChartDataCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 59, 112)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 60, 41)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + datasets: ChartDatasetCustomTypesPerDataset +>datasets : Symbol(ChartDataCustomTypesPerDataset.datasets, Decl(varianceCircularityHidesInvariance.ts, 60, 67)) +>ChartDatasetCustomTypesPerDataset : Symbol(ChartDatasetCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 58, 116)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 60, 41)) +} +export interface ChartConfigurationCustomTypesPerDataset { +>ChartConfigurationCustomTypesPerDataset : Symbol(ChartConfigurationCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 62, 1)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 63, 57)) +>ChartType : Symbol(ChartType, Decl(varianceCircularityHidesInvariance.ts, 50, 1)) + + data: ChartDataCustomTypesPerDataset +>data : Symbol(ChartConfigurationCustomTypesPerDataset.data, Decl(varianceCircularityHidesInvariance.ts, 63, 83)) +>ChartDataCustomTypesPerDataset : Symbol(ChartDataCustomTypesPerDataset, Decl(varianceCircularityHidesInvariance.ts, 59, 112)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 63, 57)) + + options: ChartOptions +>options : Symbol(ChartConfigurationCustomTypesPerDataset.options, Decl(varianceCircularityHidesInvariance.ts, 64, 47)) +>ChartOptions : Symbol(ChartOptions, Decl(varianceCircularityHidesInvariance.ts, 52, 74)) +>TType : Symbol(TType, Decl(varianceCircularityHidesInvariance.ts, 63, 57)) +} + +const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; +>p : Symbol(p, Decl(varianceCircularityHidesInvariance.ts, 68, 5)) +>Plugin : Symbol(Plugin, Decl(varianceCircularityHidesInvariance.ts, 21, 1)) +>id : Symbol(id, Decl(varianceCircularityHidesInvariance.ts, 68, 26)) +>beforeDraw : Symbol(beforeDraw, Decl(varianceCircularityHidesInvariance.ts, 68, 35)) +>chart : Symbol(chart, Decl(varianceCircularityHidesInvariance.ts, 68, 49)) +>Chart : Symbol(Chart, Decl(varianceCircularityHidesInvariance.ts, 18, 51)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).types new file mode 100644 index 0000000000000..78c2a7fbee0a8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).types @@ -0,0 +1,131 @@ +//// [tests/cases/compiler/varianceCircularityHidesInvariance.ts] //// + +=== varianceCircularityHidesInvariance.ts === +// Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and +// ScriptableContext form a variance circularity. ScriptableContext is in +// fact invariant: ScriptableContext<"bar" | "line"> is not assignable to +// ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not +// assignable to Chart and the assignment below must be an error. +// Measuring variances from the circularity's entry, main recorded +// ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and +// accepted it; main reports this error too when ScriptableContext's variance +// is measured first (e.g. after checking a ScriptableContext assignment). + +declare class Element { options: O } +>Element : Element +>options : O + +type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined +>DeepPartial : DeepPartial + +type _DeepPartialObject = { [P in keyof T]?: DeepPartial } +>_DeepPartialObject : _DeepPartialObject + +type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never +>UnionToIntersection : UnionToIntersection +>k : U +>k : I + +type AnyObject = Record +>AnyObject : AnyObject + +interface ScriptableContext { + dataset: UnionToIntersection> +>dataset : UnionToIntersection> +} +type Scriptable = (ctx: TContext) => T +>Scriptable : Scriptable +>ctx : TContext + +declare class Chart { +>Chart : Chart + + config: ChartConfigurationCustomTypesPerDataset +>config : ChartConfigurationCustomTypesPerDataset +} +interface Plugin { + id: string; +>id : string + + beforeDraw(chart: Chart): void +>beforeDraw : (chart: Chart) => void +>chart : Chart +} +interface CoreChartOptions { + backgroundColor: Scriptable> +>backgroundColor : Scriptable> +} +interface AnimationSpec { + delay: Scriptable> +>delay : Scriptable> +} +interface TooltipModel extends Element> { + chart: Chart +>chart : Chart +} +interface TooltipDatasetCallbacks> { + (this: Model): void +>this : Model +} +interface TooltipOptions { + animation: AnimationSpec +>animation : AnimationSpec +} +interface TooltipDatasetOptions { + callbacks: TooltipDatasetCallbacks +>callbacks : TooltipDatasetCallbacks> +} +interface PluginDatasetOptionsByType { + tooltip: TooltipDatasetOptions +>tooltip : TooltipDatasetOptions +} +interface ChartTypeRegistry { + bar: { defaultDataPoint: [] } +>bar : { defaultDataPoint: []; } +>defaultDataPoint : [] + + line: { defaultDataPoint: null } +>line : { defaultDataPoint: null; } +>defaultDataPoint : null +} +type ChartType = keyof ChartTypeRegistry +>ChartType : keyof ChartTypeRegistry + +type DatasetChartOptions = { [key in TType]: {} } +>DatasetChartOptions : DatasetChartOptions + +type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> +>ChartOptions : ChartOptions + +interface ChartDatasetProperties { + data: TData +>data : TData +} +type ChartDataset = +>ChartDataset : ChartDataset + + DeepPartial> & ChartDatasetProperties +type ChartDatasetCustomTypesPerDataset = DeepPartial> +>ChartDatasetCustomTypesPerDataset : _DeepPartialObject> + +interface ChartDataCustomTypesPerDataset { + datasets: ChartDatasetCustomTypesPerDataset +>datasets : _DeepPartialObject> +} +export interface ChartConfigurationCustomTypesPerDataset { + data: ChartDataCustomTypesPerDataset +>data : ChartDataCustomTypesPerDataset + + options: ChartOptions +>options : Exclude & DatasetChartOptions & TType>, undefined> +} + +const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; +>p : Plugin<"bar"> +>{ id: "x", beforeDraw: (chart: Chart) => {} } : { id: string; beforeDraw: (chart: Chart) => void; } +>id : string +>"x" : "x" +>beforeDraw : (chart: Chart) => void +>(chart: Chart) => {} : (chart: Chart) => void +>chart : Chart + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.errors.txt new file mode 100644 index 0000000000000..fed3dca53a0ed --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.errors.txt @@ -0,0 +1,25 @@ +first.ts(3,1): error TS2322: Type 'Box' is not assignable to type 'Box'. + Type 'number' is not assignable to type 'string'. + + +==== first.ts (1 errors) ==== + declare let b1: Box; + declare let b2: Box; + b1 = b2; + ~~ +!!! error TS2322: Type 'Box' is not assignable to type 'Box'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + +==== box.ts (0 errors) ==== + declare let a1: Box; + declare let a2: Box; + declare const cond: boolean; + class Box { + value!: T; + m() { + if (cond) return a1; + return a2; + } + } + const r = new Box().m(); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.js b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.js new file mode 100644 index 0000000000000..1cc3125377745 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/varianceCycleCachedResults.ts] //// + +//// [first.ts] +declare let b1: Box; +declare let b2: Box; +b1 = b2; + +//// [box.ts] +declare let a1: Box; +declare let a2: Box; +declare const cond: boolean; +class Box { + value!: T; + m() { + if (cond) return a1; + return a2; + } +} +const r = new Box().m(); + + +//// [first.js] +"use strict"; +b1 = b2; +//// [box.js] +"use strict"; +class Box { + value; + m() { + if (cond) + return a1; + return a2; + } +} +const r = new Box().m(); diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.symbols new file mode 100644 index 0000000000000..84c44e9268207 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.symbols @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/varianceCycleCachedResults.ts] //// + +=== first.ts === +declare let b1: Box; +>b1 : Symbol(b1, Decl(first.ts, 0, 11)) +>Box : Symbol(Box, Decl(box.ts, 2, 28)) + +declare let b2: Box; +>b2 : Symbol(b2, Decl(first.ts, 1, 11)) +>Box : Symbol(Box, Decl(box.ts, 2, 28)) + +b1 = b2; +>b1 : Symbol(b1, Decl(first.ts, 0, 11)) +>b2 : Symbol(b2, Decl(first.ts, 1, 11)) + +=== box.ts === +declare let a1: Box; +>a1 : Symbol(a1, Decl(box.ts, 0, 11)) +>Box : Symbol(Box, Decl(box.ts, 2, 28)) + +declare let a2: Box; +>a2 : Symbol(a2, Decl(box.ts, 1, 11)) +>Box : Symbol(Box, Decl(box.ts, 2, 28)) + +declare const cond: boolean; +>cond : Symbol(cond, Decl(box.ts, 2, 13)) + +class Box { +>Box : Symbol(Box, Decl(box.ts, 2, 28)) +>T : Symbol(T, Decl(box.ts, 3, 10)) + + value!: T; +>value : Symbol(Box.value, Decl(box.ts, 3, 14)) +>T : Symbol(T, Decl(box.ts, 3, 10)) + + m() { +>m : Symbol(Box.m, Decl(box.ts, 4, 14)) + + if (cond) return a1; +>cond : Symbol(cond, Decl(box.ts, 2, 13)) +>a1 : Symbol(a1, Decl(box.ts, 0, 11)) + + return a2; +>a2 : Symbol(a2, Decl(box.ts, 1, 11)) + } +} +const r = new Box().m(); +>r : Symbol(r, Decl(box.ts, 10, 5)) +>new Box().m : Symbol(Box.m, Decl(box.ts, 4, 14)) +>Box : Symbol(Box, Decl(box.ts, 2, 28)) +>m : Symbol(Box.m, Decl(box.ts, 4, 14)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.types b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.types new file mode 100644 index 0000000000000..c5448fc75d3ab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.types @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/varianceCycleCachedResults.ts] //// + +=== first.ts === +declare let b1: Box; +>b1 : Box + +declare let b2: Box; +>b2 : Box + +b1 = b2; +>b1 = b2 : Box +>b1 : Box +>b2 : Box + +=== box.ts === +declare let a1: Box; +>a1 : Box + +declare let a2: Box; +>a2 : Box + +declare const cond: boolean; +>cond : boolean + +class Box { +>Box : Box + + value!: T; +>value : T + + m() { +>m : () => Box + + if (cond) return a1; +>cond : boolean +>a1 : Box + + return a2; +>a2 : Box + } +} +const r = new Box().m(); +>r : Box +>new Box().m() : Box +>new Box().m : () => Box +>new Box() : Box +>Box : typeof Box +>m : () => Box + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.symbols new file mode 100644 index 0000000000000..ba9c1355e14cb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.symbols @@ -0,0 +1,754 @@ +//// [tests/cases/compiler/varianceCycleCapnwebRpcStub.ts] //// + +=== capnweb.d.ts === +// Copyright (c) 2025 Cloudflare, Inc. +// Licensed under the MIT license found in the LICENSE.txt file or at: +// https://opensource.org/license/mit +// This file borrows heavily from `types/defines/rpc.d.ts` in workerd. +// Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s. +// TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`. +// For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to +// accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape) +declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND'; +>__RPC_STUB_BRAND : Symbol(__RPC_STUB_BRAND, Decl(capnweb.d.ts, 8, 13)) + +declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND'; +>__RPC_TARGET_BRAND : Symbol(__RPC_TARGET_BRAND, Decl(capnweb.d.ts, 9, 13)) + +// Distinguishes mapper placeholders from regular values so param unwrapping can accept them. +declare const __RPC_MAP_VALUE_BRAND: unique symbol; +>__RPC_MAP_VALUE_BRAND : Symbol(__RPC_MAP_VALUE_BRAND, Decl(capnweb.d.ts, 11, 13)) + +interface RpcTargetBranded { +>RpcTargetBranded : Symbol(RpcTargetBranded, Decl(capnweb.d.ts, 11, 51)) + + [__RPC_TARGET_BRAND]: never; +>[__RPC_TARGET_BRAND] : Symbol(RpcTargetBranded[__RPC_TARGET_BRAND], Decl(capnweb.d.ts, 12, 28)) +>__RPC_TARGET_BRAND : Symbol(__RPC_TARGET_BRAND, Decl(capnweb.d.ts, 9, 13)) +} +// Types that can be used through `Stub`s +// `never[]` preserves compatibility with strongly-typed function signatures without introducing +// `any` into inference. +type Stubable = RpcTargetBranded | ((...args: never[]) => unknown); +>Stubable : Symbol(Stubable, Decl(capnweb.d.ts, 14, 1)) +>RpcTargetBranded : Symbol(RpcTargetBranded, Decl(capnweb.d.ts, 11, 51)) +>args : Symbol(args, Decl(capnweb.d.ts, 18, 37)) + +// Note: also true for `any` (call sites that care check `IsAny` first). +type IsUnknown = unknown extends T ? true : false; // Types that can be passed over RPC +>IsUnknown : Symbol(IsUnknown, Decl(capnweb.d.ts, 18, 67)) +>T : Symbol(T, Decl(capnweb.d.ts, 20, 15)) +>T : Symbol(T, Decl(capnweb.d.ts, 20, 15)) + +// The reason for using a generic type here is to build the serializable subset of RPC-compatible +// composite types. This allows types defined with the "interface" keyword to pass the +// serializable check as well. Otherwise, only types defined with the "type" keyword would pass. +type RpcCompatible = // Allow `unknown` as a leaf so records/interfaces with `unknown` fields remain compatible. +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) + +(IsUnknown extends true ? unknown : never) // RPC-compatible base values +>IsUnknown : Symbol(IsUnknown, Decl(capnweb.d.ts, 18, 67)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) + +| BaseType // RPC-compatible composites +>BaseType : Symbol(BaseType, Decl(capnweb.d.ts, 38, 178)) + +| Map ? RpcCompatible : never, T extends Map ? RpcCompatible : never> | Set ? RpcCompatible : never> | Array ? RpcCompatible : never> | ReadonlyArray ? RpcCompatible : never> | { [K in keyof T as K extends string | number ? K : never]: RpcCompatible } | Promise ? RpcCompatible : never> // Special types +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 25)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 25)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 94)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 94)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 151)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 151)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 212)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 212)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 289)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 289)) +>K : Symbol(K, Decl(capnweb.d.ts, 27, 326)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>K : Symbol(K, Decl(capnweb.d.ts, 27, 326)) +>K : Symbol(K, Decl(capnweb.d.ts, 27, 326)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>K : Symbol(K, Decl(capnweb.d.ts, 27, 326)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 24, 19)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 437)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>U : Symbol(U, Decl(capnweb.d.ts, 27, 437)) + +| Stub // Serialized as stubs, see `Stubify` +>Stub : Symbol(Stub, Decl(capnweb.d.ts, 36, 1)) +>Stubable : Symbol(Stubable, Decl(capnweb.d.ts, 14, 1)) + +| Stubable; +>Stubable : Symbol(Stubable, Decl(capnweb.d.ts, 14, 1)) + +// Base type for all RPC stubs, including common memory management methods. +// `T` is used as a marker type for unwrapping `Stub`s later. +interface StubBase extends Disposable { +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>T : Symbol(T, Decl(capnweb.d.ts, 32, 19)) +>Disposable : Symbol(Disposable, Decl(lib.esnext.disposable.d.ts, --, --)) + + [__RPC_STUB_BRAND]: T; +>[__RPC_STUB_BRAND] : Symbol(StubBase[__RPC_STUB_BRAND], Decl(capnweb.d.ts, 32, 52)) +>__RPC_STUB_BRAND : Symbol(__RPC_STUB_BRAND, Decl(capnweb.d.ts, 8, 13)) +>T : Symbol(T, Decl(capnweb.d.ts, 32, 19)) + + dup(): this; +>dup : Symbol(StubBase.dup, Decl(capnweb.d.ts, 33, 24)) + + onRpcBroken(callback: (error: any) => void): void; +>onRpcBroken : Symbol(StubBase.onRpcBroken, Decl(capnweb.d.ts, 34, 14)) +>callback : Symbol(callback, Decl(capnweb.d.ts, 35, 14)) +>error : Symbol(error, Decl(capnweb.d.ts, 35, 25)) +} +type Stub> = T extends object ? Provider & StubBase : StubBase; +>Stub : Symbol(Stub, Decl(capnweb.d.ts, 36, 1)) +>T : Symbol(T, Decl(capnweb.d.ts, 37, 10)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>T : Symbol(T, Decl(capnweb.d.ts, 37, 10)) +>T : Symbol(T, Decl(capnweb.d.ts, 37, 10)) +>Provider : Symbol(Provider, Decl(capnweb.d.ts, 137, 135)) +>T : Symbol(T, Decl(capnweb.d.ts, 37, 10)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>T : Symbol(T, Decl(capnweb.d.ts, 37, 10)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>T : Symbol(T, Decl(capnweb.d.ts, 37, 10)) + +type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array; // This represents all the types that can be sent as-is over an RPC boundary +>TypedArray : Symbol(TypedArray, Decl(capnweb.d.ts, 37, 99)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) +>Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) +>Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) +>Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) +>Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) +>Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) +>BigUint64Array : Symbol(BigUint64Array, Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2022.array.d.ts, --, --), Decl(lib.es2023.array.d.ts, --, --)) +>BigInt64Array : Symbol(BigInt64Array, Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2022.array.d.ts, --, --), Decl(lib.es2023.array.d.ts, --, --)) +>Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) +>Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 3 more) + +type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | Blob | ReadableStream // Chunk type can be any RPC-compatible type +>BaseType : Symbol(BaseType, Decl(capnweb.d.ts, 38, 178)) +>TypedArray : Symbol(TypedArray, Decl(capnweb.d.ts, 37, 99)) +>ArrayBuffer : Symbol(ArrayBuffer, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2024.arraybuffer.d.ts, --, --)) +>DataView : Symbol(DataView, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2020.bigint.d.ts, --, --), Decl(lib.es2025.float16.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2020.date.d.ts, --, --) ... and 1 more) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) +>RegExp : Symbol(RegExp, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.regexp.d.ts, --, --) ... and 3 more) +>Blob : Symbol(Blob, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +>ReadableStream : Symbol(ReadableStream, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) + +| WritableStream // Chunk type can be any RPC-compatible type +>WritableStream : Symbol(WritableStream, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) + +| URL | Request | Response | Headers; // Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises. +>URL : Symbol(URL, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +>Request : Symbol(Request, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +>Response : Symbol(Response, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) +>Headers : Symbol(Headers, Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --), Decl(lib.dom.d.ts, --, --)) + +// Arm ordering matters here: +// - `Promise` must come before `StubBase`: `RpcPromise` matches both, and must resolve +// through the Promise arm rather than pass through as-is. +// - `StubBase` must come before `Stubable`: `Stub` of a callable `T` is itself callable, so +// it matches `Stubable`. Checking `StubBase` first keeps existing stubs as-is instead of +// double-wrapping them as `Stub>`. +// prettier-ignore +type Stubify = T extends Promise ? Stubify : T extends StubBase ? T : T extends Stubable ? Stub : T extends Map ? Map, Stubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Stubify, ...Stubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Stubify, ...Stubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T // When using "unknown" instead of "any", interfaces are not stubified. +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>U : Symbol(U, Decl(capnweb.d.ts, 49, 41)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>U : Symbol(U, Decl(capnweb.d.ts, 49, 41)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>Stubable : Symbol(Stubable, Decl(capnweb.d.ts, 14, 1)) +>Stub : Symbol(Stub, Decl(capnweb.d.ts, 36, 1)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>K : Symbol(K, Decl(capnweb.d.ts, 49, 140)) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 149)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>K : Symbol(K, Decl(capnweb.d.ts, 49, 140)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 149)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 204)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 204)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 49, 264)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 49, 279)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 49, 264)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 49, 279)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 49, 387)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 49, 402)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 49, 387)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 49, 402)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 477)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 477)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 532)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>V : Symbol(V, Decl(capnweb.d.ts, 49, 532)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>BaseType : Symbol(BaseType, Decl(capnweb.d.ts, 38, 178)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) + +: T extends { +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) + + [key: string | number]: any; +>key : Symbol(key, Decl(capnweb.d.ts, 51, 3)) + +} ? { [K in keyof T as K extends string | number ? K : never]: Stubify } : T; +>K : Symbol(K, Decl(capnweb.d.ts, 52, 7)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>K : Symbol(K, Decl(capnweb.d.ts, 52, 7)) +>K : Symbol(K, Decl(capnweb.d.ts, 52, 7)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) +>K : Symbol(K, Decl(capnweb.d.ts, 52, 7)) +>T : Symbol(T, Decl(capnweb.d.ts, 49, 13)) + +// Recursively rewrite all `Stub`s with the corresponding `T`s. +// Note we use `StubBase` instead of `Stub` here to avoid circular dependencies: +// `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`. +// prettier-ignore +type UnstubifyInner = // Preserve local RpcTarget acceptance, but avoid needless `Stub | Value` unions when the stub +>UnstubifyInner : Symbol(UnstubifyInner, Decl(capnweb.d.ts, 52, 83)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) + +// is already assignable to the value type (important for callback contextual typing). +T extends StubBase ? (T extends V ? UnstubifyInner : (T | UnstubifyInner)) : T extends Promise ? UnstubifyInner : T extends Map ? Map, Unstubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Unstubify, ...Unstubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Unstubify, ...Unstubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T : T extends { +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 24)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 24)) +>UnstubifyInner : Symbol(UnstubifyInner, Decl(capnweb.d.ts, 52, 83)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 24)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>UnstubifyInner : Symbol(UnstubifyInner, Decl(capnweb.d.ts, 52, 83)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 24)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>U : Symbol(U, Decl(capnweb.d.ts, 59, 115)) +>UnstubifyInner : Symbol(UnstubifyInner, Decl(capnweb.d.ts, 52, 83)) +>U : Symbol(U, Decl(capnweb.d.ts, 59, 115)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>K : Symbol(K, Decl(capnweb.d.ts, 59, 160)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 169)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>K : Symbol(K, Decl(capnweb.d.ts, 59, 160)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 169)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 228)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 228)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 59, 290)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 59, 305)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 59, 290)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 59, 305)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 59, 417)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 59, 432)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 59, 417)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 59, 432)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 511)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 511)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 568)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>V : Symbol(V, Decl(capnweb.d.ts, 59, 568)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>BaseType : Symbol(BaseType, Decl(capnweb.d.ts, 38, 178)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) + + [key: string | number]: unknown; +>key : Symbol(key, Decl(capnweb.d.ts, 60, 3)) + +} ? { [K in keyof T as K extends string | number ? K : never]: Unstubify } : T; // You can put promises anywhere in the params and they'll be resolved before delivery. +>K : Symbol(K, Decl(capnweb.d.ts, 61, 7)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>K : Symbol(K, Decl(capnweb.d.ts, 61, 7)) +>K : Symbol(K, Decl(capnweb.d.ts, 61, 7)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) +>K : Symbol(K, Decl(capnweb.d.ts, 61, 7)) +>T : Symbol(T, Decl(capnweb.d.ts, 57, 20)) + +// (This also covers RpcPromise, because it's defined as being a Promise.) +// Map placeholders are also allowed so primitive map callback inputs can be forwarded directly +// into RPC params. +// +// Keep raw non-stub members so generic assignability still works when UnstubifyInner is deferred. +// Remove stub members from mixed unions so callback params don’t get both stub and unstubbed signatures. +// Marker carried by map() callback inputs. This lets primitive placeholders flow through params. +type Unstubify = NonStubMembers | UnstubifyInner | Promise> | MapValuePlaceholder>; +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>T : Symbol(T, Decl(capnweb.d.ts, 69, 15)) +>NonStubMembers : Symbol(NonStubMembers, Decl(capnweb.d.ts, 73, 1)) +>T : Symbol(T, Decl(capnweb.d.ts, 69, 15)) +>UnstubifyInner : Symbol(UnstubifyInner, Decl(capnweb.d.ts, 52, 83)) +>T : Symbol(T, Decl(capnweb.d.ts, 69, 15)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>UnstubifyInner : Symbol(UnstubifyInner, Decl(capnweb.d.ts, 52, 83)) +>T : Symbol(T, Decl(capnweb.d.ts, 69, 15)) +>MapValuePlaceholder : Symbol(MapValuePlaceholder, Decl(capnweb.d.ts, 70, 86)) +>UnstubifyInner : Symbol(UnstubifyInner, Decl(capnweb.d.ts, 52, 83)) +>T : Symbol(T, Decl(capnweb.d.ts, 69, 15)) + +type UnstubifyAll = { [I in keyof A]: Unstubify }; +>UnstubifyAll : Symbol(UnstubifyAll, Decl(capnweb.d.ts, 69, 128)) +>A : Symbol(A, Decl(capnweb.d.ts, 70, 18)) +>I : Symbol(I, Decl(capnweb.d.ts, 70, 53)) +>A : Symbol(A, Decl(capnweb.d.ts, 70, 18)) +>Unstubify : Symbol(Unstubify, Decl(capnweb.d.ts, 61, 85)) +>A : Symbol(A, Decl(capnweb.d.ts, 70, 18)) +>I : Symbol(I, Decl(capnweb.d.ts, 70, 53)) + +interface MapValuePlaceholder { +>MapValuePlaceholder : Symbol(MapValuePlaceholder, Decl(capnweb.d.ts, 70, 86)) +>T : Symbol(T, Decl(capnweb.d.ts, 71, 30)) + + [__RPC_MAP_VALUE_BRAND]: T; +>[__RPC_MAP_VALUE_BRAND] : Symbol(MapValuePlaceholder[__RPC_MAP_VALUE_BRAND], Decl(capnweb.d.ts, 71, 34)) +>__RPC_MAP_VALUE_BRAND : Symbol(__RPC_MAP_VALUE_BRAND, Decl(capnweb.d.ts, 11, 13)) +>T : Symbol(T, Decl(capnweb.d.ts, 71, 30)) +} +type NonStubMembers = Exclude>; // Utility type for adding `Disposable`s to `object` types only. +>NonStubMembers : Symbol(NonStubMembers, Decl(capnweb.d.ts, 73, 1)) +>T : Symbol(T, Decl(capnweb.d.ts, 74, 20)) +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 74, 20)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) + +// Note `unknown & T` is equivalent to `T`. +type MaybeDisposable = T extends object ? Disposable : unknown; // The type behind the public `RpcPromise` (re-exported with its `RpcCompatible` constraint from +>MaybeDisposable : Symbol(MaybeDisposable, Decl(capnweb.d.ts, 74, 51)) +>T : Symbol(T, Decl(capnweb.d.ts, 76, 21)) +>T : Symbol(T, Decl(capnweb.d.ts, 76, 21)) +>Disposable : Symbol(Disposable, Decl(lib.esnext.disposable.d.ts, --, --)) + +// index.ts). Defined here so that `Result`'s arms below resolve to the exact same alias +// instantiation: when both sides of an assignability check are the same alias applied to the +// same type arguments, the checker short-circuits on identity instead of recursing through the +// full structural comparison of these mutually-recursive types. +type RpcPromise$1 = T extends Stubable ? Promise> & Provider & StubBase : Promise & MaybeDisposable> & Provider & StubBase; +>RpcPromise$1 : Symbol(RpcPromise$1, Decl(capnweb.d.ts, 76, 66)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>Stubable : Symbol(Stubable, Decl(capnweb.d.ts, 14, 1)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(capnweb.d.ts, 36, 1)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>Provider : Symbol(Provider, Decl(capnweb.d.ts, 137, 135)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stubify : Symbol(Stubify, Decl(capnweb.d.ts, 41, 37)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>MaybeDisposable : Symbol(MaybeDisposable, Decl(capnweb.d.ts, 74, 51)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>Provider : Symbol(Provider, Decl(capnweb.d.ts, 137, 135)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>T : Symbol(T, Decl(capnweb.d.ts, 81, 18)) + +// The elision `Result` applies to a bare stub type: unwrap `Stub` back to `T` when the +// payload is `Stubable`. Such stubs await back to a stub either way, so eliding keeps a +// declared `Promise>` return interchangeable with a `Promise` return. +// Plain-interface stubs are NOT elided: `RpcPromise` only awaits to `Stub` when +// `U extends Stubable`, so eliding those would change the awaited type from a stub to a +// stubified record. The payload check is deliberately non-distributive (`[U] extends [...]`). +// `Stub` is not elided either: `[any] extends [Stubable]` is true, so without the `IsAny` +// guard an `any`-payload stub would lose its stub surface. +// Also used by the `RpcPromise` constructor signature (index.ts), which applies exactly this +// transformation so constructing from a promised stub matches the method-return type. +type ElideStub = T extends StubBase ? (IsAny extends true ? T : [U] extends [Stubable] ? U : T) : T; +>ElideStub : Symbol(ElideStub, Decl(capnweb.d.ts, 81, 160)) +>T : Symbol(T, Decl(capnweb.d.ts, 92, 15)) +>T : Symbol(T, Decl(capnweb.d.ts, 92, 15)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>U : Symbol(U, Decl(capnweb.d.ts, 92, 44)) +>IsAny : Symbol(IsAny, Decl(capnweb.d.ts, 115, 110)) +>U : Symbol(U, Decl(capnweb.d.ts, 92, 44)) +>T : Symbol(T, Decl(capnweb.d.ts, 92, 15)) +>U : Symbol(U, Decl(capnweb.d.ts, 92, 44)) +>Stubable : Symbol(Stubable, Decl(capnweb.d.ts, 14, 1)) +>U : Symbol(U, Decl(capnweb.d.ts, 92, 44)) +>T : Symbol(T, Decl(capnweb.d.ts, 92, 15)) +>T : Symbol(T, Decl(capnweb.d.ts, 92, 15)) + +// What the promise given to `new RpcPromise(...)` may resolve to: the payload itself, or — +// for stubable payloads — a stub of it. `NoInfer` keeps the stub arm out of inference, so an +// inferred `T` is always the promise's own resolution type; the arm only matters when `T` is +// explicitly annotated (`new RpcPromise(promiseOfStub)`). Stubs of non-stubable +// payloads are deliberately rejected: `ElideStub` wouldn't elide those, so accepting one would +// claim the promise awaits to a stubified record while the runtime resolves to a stub. +type PayloadOrStub = T | NoInfer>>; +>PayloadOrStub : Symbol(PayloadOrStub, Decl(capnweb.d.ts, 92, 115)) +>T : Symbol(T, Decl(capnweb.d.ts, 99, 19)) +>T : Symbol(T, Decl(capnweb.d.ts, 99, 19)) +>NoInfer : Symbol(NoInfer, Decl(lib.es5.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(capnweb.d.ts, 36, 1)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 99, 19)) +>Stubable : Symbol(Stubable, Decl(capnweb.d.ts, 14, 1)) + +// Type for method return or property on an RPC interface. +// - Stubable types are replaced by stubs. +// - RpcCompatible types are passed by value, with stubable types replaced by stubs +// and a top-level `Disposer`. +// Everything else can't be passed over RPC. +// Technically, we use custom thenables here, but they quack like `Promise`s. +// Intersecting with `(Maybe)Provider` allows pipelining. +// prettier-ignore +type Result = IsAny extends true ? RpcPromise$1 // `RpcPromise`: always safe to normalize — `Result` is idempotent — so a declared +>Result : Symbol(Result, Decl(capnweb.d.ts, 99, 64)) +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) +>IsAny : Symbol(IsAny, Decl(capnweb.d.ts, 115, 110)) +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) +>RpcPromise$1 : Symbol(RpcPromise$1, Decl(capnweb.d.ts, 76, 66)) + +// `RpcPromise` return produces the same type as a `Promise` return. +: R extends PromiseLike & StubBase ? Result // Bare stubs: elide per `ElideStub` above. Note there is no `RpcCompatible` re-check +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>U : Symbol(U, Decl(capnweb.d.ts, 110, 49)) +>Result : Symbol(Result, Decl(capnweb.d.ts, 99, 64)) +>U : Symbol(U, Decl(capnweb.d.ts, 110, 49)) + +// here: anything matching our `StubBase` was produced by machinery that already enforced +// the constraint, and re-evaluating `RpcCompatible` in this arm recurses through its +// `Stub` member back into `Result`, tripping TS2615 circularity errors in mapped +// types. +: R extends StubBase ? RpcPromise$1> : R extends RpcCompatible ? RpcPromise$1 : never; +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>RpcPromise$1 : Symbol(RpcPromise$1, Decl(capnweb.d.ts, 76, 66)) +>ElideStub : Symbol(ElideStub, Decl(capnweb.d.ts, 81, 160)) +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) +>RpcPromise$1 : Symbol(RpcPromise$1, Decl(capnweb.d.ts, 76, 66)) +>R : Symbol(R, Decl(capnweb.d.ts, 108, 12)) + +type IsAny = 0 extends (1 & T) ? true : false; // Type for method or property on an RPC interface. +>IsAny : Symbol(IsAny, Decl(capnweb.d.ts, 115, 110)) +>T : Symbol(T, Decl(capnweb.d.ts, 116, 11)) +>T : Symbol(T, Decl(capnweb.d.ts, 116, 11)) + +// For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s. +// Unwrapping `Stub`s allows calling with `Stubable` arguments. +// For properties, rewrite types to be `Result`s. +// In each case, unwrap `Promise`s. +type MethodOrProperty = V extends ((...args: infer P) => infer R) ? (...args: UnstubifyAll

) => Result> : Result>; // Type for the callable part of an `Provider` if `T` is callable. +>MethodOrProperty : Symbol(MethodOrProperty, Decl(capnweb.d.ts, 116, 49)) +>V : Symbol(V, Decl(capnweb.d.ts, 121, 22)) +>V : Symbol(V, Decl(capnweb.d.ts, 121, 22)) +>args : Symbol(args, Decl(capnweb.d.ts, 121, 39)) +>P : Symbol(P, Decl(capnweb.d.ts, 121, 53)) +>R : Symbol(R, Decl(capnweb.d.ts, 121, 65)) +>args : Symbol(args, Decl(capnweb.d.ts, 121, 72)) +>UnstubifyAll : Symbol(UnstubifyAll, Decl(capnweb.d.ts, 69, 128)) +>P : Symbol(P, Decl(capnweb.d.ts, 121, 53)) +>Result : Symbol(Result, Decl(capnweb.d.ts, 99, 64)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>R : Symbol(R, Decl(capnweb.d.ts, 121, 65)) +>Result : Symbol(Result, Decl(capnweb.d.ts, 99, 64)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>V : Symbol(V, Decl(capnweb.d.ts, 121, 22)) + +// This is intersected with methods/properties. +type MaybeCallableProvider = T extends ((...args: any[]) => any) ? MethodOrProperty : unknown; +>MaybeCallableProvider : Symbol(MaybeCallableProvider, Decl(capnweb.d.ts, 121, 141)) +>T : Symbol(T, Decl(capnweb.d.ts, 123, 27)) +>T : Symbol(T, Decl(capnweb.d.ts, 123, 27)) +>args : Symbol(args, Decl(capnweb.d.ts, 123, 44)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(capnweb.d.ts, 116, 49)) +>T : Symbol(T, Decl(capnweb.d.ts, 123, 27)) + +type TupleIndexKeys> = Extract; +>TupleIndexKeys : Symbol(TupleIndexKeys, Decl(capnweb.d.ts, 123, 100)) +>T : Symbol(T, Decl(capnweb.d.ts, 124, 20)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 124, 20)) + +type MapCallbackValue = // `Omit` removes call signatures, so re-intersect callable provider behavior. +>MapCallbackValue : Symbol(MapCallbackValue, Decl(capnweb.d.ts, 124, 86)) +>T : Symbol(T, Decl(capnweb.d.ts, 125, 22)) + +T extends unknown ? Omit, keyof Promise> & MaybeCallableProvider & MapValuePlaceholder : never; +>T : Symbol(T, Decl(capnweb.d.ts, 125, 22)) +>Omit : Symbol(Omit, Decl(lib.es5.d.ts, --, --)) +>Result : Symbol(Result, Decl(capnweb.d.ts, 99, 64)) +>T : Symbol(T, Decl(capnweb.d.ts, 125, 22)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>MaybeCallableProvider : Symbol(MaybeCallableProvider, Decl(capnweb.d.ts, 121, 141)) +>T : Symbol(T, Decl(capnweb.d.ts, 125, 22)) +>MapValuePlaceholder : Symbol(MapValuePlaceholder, Decl(capnweb.d.ts, 70, 86)) +>T : Symbol(T, Decl(capnweb.d.ts, 125, 22)) + +type InvalidNativePromiseInMapResult = T extends unknown ? InvalidNativePromiseInMapResultImpl : never; +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>T : Symbol(T, Decl(capnweb.d.ts, 127, 37)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 127, 39)) +>T : Symbol(T, Decl(capnweb.d.ts, 127, 37)) +>InvalidNativePromiseInMapResultImpl : Symbol(InvalidNativePromiseInMapResultImpl, Decl(capnweb.d.ts, 127, 129)) +>T : Symbol(T, Decl(capnweb.d.ts, 127, 37)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 127, 39)) + +type InvalidNativePromiseInMapResultImpl = [T] extends [Seen] ? never // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values. +>InvalidNativePromiseInMapResultImpl : Symbol(InvalidNativePromiseInMapResultImpl, Decl(capnweb.d.ts, 127, 129)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) + +: T extends StubBase ? never // Native thenables cannot be represented in map recordings, even when typed as PromiseLike. +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) + +: T extends PromiseLike ? T : T extends Map ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends Set ? InvalidNativePromiseInMapResult : T extends readonly [] ? never : T extends readonly [infer Head, ...infer Tail] ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends ReadonlyArray ? InvalidNativePromiseInMapResult : T extends { +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>K : Symbol(K, Decl(capnweb.d.ts, 130, 58)) +>V : Symbol(V, Decl(capnweb.d.ts, 130, 67)) +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>K : Symbol(K, Decl(capnweb.d.ts, 130, 58)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>V : Symbol(V, Decl(capnweb.d.ts, 130, 67)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) +>V : Symbol(V, Decl(capnweb.d.ts, 130, 186)) +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>V : Symbol(V, Decl(capnweb.d.ts, 130, 186)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 130, 296)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 130, 311)) +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>Head : Symbol(Head, Decl(capnweb.d.ts, 130, 296)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>Tail : Symbol(Tail, Decl(capnweb.d.ts, 130, 311)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>V : Symbol(V, Decl(capnweb.d.ts, 130, 457)) +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>V : Symbol(V, Decl(capnweb.d.ts, 130, 457)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) + + [key: string | number]: unknown; +>key : Symbol(key, Decl(capnweb.d.ts, 131, 3)) + +} ? InvalidNativePromiseInMapResult], Seen | T> : never; +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) +>Seen : Symbol(Seen, Decl(capnweb.d.ts, 128, 43)) +>T : Symbol(T, Decl(capnweb.d.ts, 128, 41)) + +type MapCallbackReturn = InvalidNativePromiseInMapResult extends never ? T : never; +>MapCallbackReturn : Symbol(MapCallbackReturn, Decl(capnweb.d.ts, 132, 92)) +>T : Symbol(T, Decl(capnweb.d.ts, 133, 23)) +>InvalidNativePromiseInMapResult : Symbol(InvalidNativePromiseInMapResult, Decl(capnweb.d.ts, 126, 120)) +>T : Symbol(T, Decl(capnweb.d.ts, 133, 23)) +>T : Symbol(T, Decl(capnweb.d.ts, 133, 23)) + +type ArrayProvider = { [K in number]: MethodOrProperty } & { +>ArrayProvider : Symbol(ArrayProvider, Decl(capnweb.d.ts, 133, 89)) +>E : Symbol(E, Decl(capnweb.d.ts, 134, 19)) +>K : Symbol(K, Decl(capnweb.d.ts, 134, 27)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(capnweb.d.ts, 116, 49)) +>E : Symbol(E, Decl(capnweb.d.ts, 134, 19)) + + map(callback: (elem: MapCallbackValue) => MapCallbackReturn): Result>; +>map : Symbol(map, Decl(capnweb.d.ts, 134, 66)) +>V : Symbol(V, Decl(capnweb.d.ts, 135, 6)) +>callback : Symbol(callback, Decl(capnweb.d.ts, 135, 9)) +>elem : Symbol(elem, Decl(capnweb.d.ts, 135, 20)) +>MapCallbackValue : Symbol(MapCallbackValue, Decl(capnweb.d.ts, 124, 86)) +>E : Symbol(E, Decl(capnweb.d.ts, 134, 19)) +>MapCallbackReturn : Symbol(MapCallbackReturn, Decl(capnweb.d.ts, 132, 92)) +>V : Symbol(V, Decl(capnweb.d.ts, 135, 6)) +>Result : Symbol(Result, Decl(capnweb.d.ts, 99, 64)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>V : Symbol(V, Decl(capnweb.d.ts, 135, 6)) + +}; +type TupleProvider> = { [K in TupleIndexKeys]: MethodOrProperty } & ArrayProvider; // Base type for all other types providing RPC-like interfaces. +>TupleProvider : Symbol(TupleProvider, Decl(capnweb.d.ts, 136, 2)) +>T : Symbol(T, Decl(capnweb.d.ts, 137, 19)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>K : Symbol(K, Decl(capnweb.d.ts, 137, 58)) +>TupleIndexKeys : Symbol(TupleIndexKeys, Decl(capnweb.d.ts, 123, 100)) +>T : Symbol(T, Decl(capnweb.d.ts, 137, 19)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(capnweb.d.ts, 116, 49)) +>T : Symbol(T, Decl(capnweb.d.ts, 137, 19)) +>K : Symbol(K, Decl(capnweb.d.ts, 137, 58)) +>ArrayProvider : Symbol(ArrayProvider, Decl(capnweb.d.ts, 133, 89)) +>T : Symbol(T, Decl(capnweb.d.ts, 137, 19)) + +// Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types. +// `__RPC_TARGET_BRAND` deliberately flows through the key mapping (as a `never` property) so +// stubs of branded targets stay assignable to workers-types' `Stubable`. Such stubs match our +// `Stubable` too — harmless, since all machinery checks `StubBase` before `Stubable`. +type Provider = MaybeCallableProvider & (T extends ReadonlyArray ? number extends T["length"] ? ArrayProvider : TupleProvider : { [K in Exclude>]: MethodOrProperty } & { +>Provider : Symbol(Provider, Decl(capnweb.d.ts, 137, 135)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>MaybeCallableProvider : Symbol(MaybeCallableProvider, Decl(capnweb.d.ts, 121, 141)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>ArrayProvider : Symbol(ArrayProvider, Decl(capnweb.d.ts, 133, 89)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>TupleProvider : Symbol(TupleProvider, Decl(capnweb.d.ts, 136, 2)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>K : Symbol(K, Decl(capnweb.d.ts, 142, 160)) +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>StubBase : Symbol(StubBase, Decl(capnweb.d.ts, 29, 11)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(capnweb.d.ts, 116, 49)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>K : Symbol(K, Decl(capnweb.d.ts, 142, 160)) + + map(callback: (value: MapCallbackValue>) => MapCallbackReturn): Result>; +>map : Symbol(map, Decl(capnweb.d.ts, 142, 244)) +>V : Symbol(V, Decl(capnweb.d.ts, 143, 6)) +>callback : Symbol(callback, Decl(capnweb.d.ts, 143, 9)) +>value : Symbol(value, Decl(capnweb.d.ts, 143, 20)) +>MapCallbackValue : Symbol(MapCallbackValue, Decl(capnweb.d.ts, 124, 86)) +>NonNullable : Symbol(NonNullable, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(capnweb.d.ts, 142, 14)) +>MapCallbackReturn : Symbol(MapCallbackReturn, Decl(capnweb.d.ts, 132, 92)) +>V : Symbol(V, Decl(capnweb.d.ts, 143, 6)) +>Result : Symbol(Result, Decl(capnweb.d.ts, 99, 64)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>V : Symbol(V, Decl(capnweb.d.ts, 143, 6)) + +}); +export type RpcStub> = Stub; +>RpcStub : Symbol(RpcStub, Decl(capnweb.d.ts, 144, 3)) +>T : Symbol(T, Decl(capnweb.d.ts, 145, 20)) +>RpcCompatible : Symbol(RpcCompatible, Decl(capnweb.d.ts, 20, 53)) +>T : Symbol(T, Decl(capnweb.d.ts, 145, 20)) +>Stub : Symbol(Stub, Decl(capnweb.d.ts, 36, 1)) +>T : Symbol(T, Decl(capnweb.d.ts, 145, 20)) + +=== main.ts === +import type { RpcStub } from "./capnweb"; +>RpcStub : Symbol(RpcStub, Decl(main.ts, 0, 13)) + +declare const api: RpcStub<{ sub(): Promise> }>; +>api : Symbol(api, Decl(main.ts, 2, 13)) +>RpcStub : Symbol(RpcStub, Decl(main.ts, 0, 13)) +>sub : Symbol(sub, Decl(main.ts, 2, 28)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>RpcStub : Symbol(RpcStub, Decl(main.ts, 0, 13)) + +export async function f() { +>f : Symbol(f, Decl(main.ts, 2, 60)) + + await api.sub(); +>api.sub : Symbol(sub) +>api : Symbol(api, Decl(main.ts, 2, 13)) +>sub : Symbol(sub) + + api.sub().then(s => s); +>api.sub().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>api.sub : Symbol(sub) +>api : Symbol(api, Decl(main.ts, 2, 13)) +>sub : Symbol(sub) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(main.ts, 5, 17)) +>s : Symbol(s, Decl(main.ts, 5, 17)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types b/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types new file mode 100644 index 0000000000000..ee9a9c413fa4f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types @@ -0,0 +1,280 @@ +//// [tests/cases/compiler/varianceCycleCapnwebRpcStub.ts] //// + +=== capnweb.d.ts === +// Copyright (c) 2025 Cloudflare, Inc. +// Licensed under the MIT license found in the LICENSE.txt file or at: +// https://opensource.org/license/mit +// This file borrows heavily from `types/defines/rpc.d.ts` in workerd. +// Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s. +// TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`. +// For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to +// accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape) +declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND'; +>__RPC_STUB_BRAND : "__RPC_STUB_BRAND" + +declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND'; +>__RPC_TARGET_BRAND : "__RPC_TARGET_BRAND" + +// Distinguishes mapper placeholders from regular values so param unwrapping can accept them. +declare const __RPC_MAP_VALUE_BRAND: unique symbol; +>__RPC_MAP_VALUE_BRAND : unique symbol + +interface RpcTargetBranded { + [__RPC_TARGET_BRAND]: never; +>[__RPC_TARGET_BRAND] : never +>__RPC_TARGET_BRAND : "__RPC_TARGET_BRAND" +} +// Types that can be used through `Stub`s +// `never[]` preserves compatibility with strongly-typed function signatures without introducing +// `any` into inference. +type Stubable = RpcTargetBranded | ((...args: never[]) => unknown); +>Stubable : Stubable +>args : never[] + +// Note: also true for `any` (call sites that care check `IsAny` first). +type IsUnknown = unknown extends T ? true : false; // Types that can be passed over RPC +>IsUnknown : IsUnknown +>true : true +>false : false + +// The reason for using a generic type here is to build the serializable subset of RPC-compatible +// composite types. This allows types defined with the "interface" keyword to pass the +// serializable check as well. Otherwise, only types defined with the "type" keyword would pass. +type RpcCompatible = // Allow `unknown` as a leaf so records/interfaces with `unknown` fields remain compatible. +>RpcCompatible : RpcCompatible + +(IsUnknown extends true ? unknown : never) // RPC-compatible base values +>true : true + +| BaseType // RPC-compatible composites +| Map ? RpcCompatible : never, T extends Map ? RpcCompatible : never> | Set ? RpcCompatible : never> | Array ? RpcCompatible : never> | ReadonlyArray ? RpcCompatible : never> | { [K in keyof T as K extends string | number ? K : never]: RpcCompatible } | Promise ? RpcCompatible : never> // Special types +| Stub // Serialized as stubs, see `Stubify` +| Stubable; +// Base type for all RPC stubs, including common memory management methods. +// `T` is used as a marker type for unwrapping `Stub`s later. +interface StubBase extends Disposable { + [__RPC_STUB_BRAND]: T; +>[__RPC_STUB_BRAND] : T +>__RPC_STUB_BRAND : "__RPC_STUB_BRAND" + + dup(): this; +>dup : () => this + + onRpcBroken(callback: (error: any) => void): void; +>onRpcBroken : (callback: (error: any) => void) => void +>callback : (error: any) => void +>error : any +} +type Stub> = T extends object ? Provider & StubBase : StubBase; +>Stub : Stub + +type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array; // This represents all the types that can be sent as-is over an RPC boundary +>TypedArray : TypedArray + +type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | Blob | ReadableStream // Chunk type can be any RPC-compatible type +>BaseType : BaseType + +| WritableStream // Chunk type can be any RPC-compatible type +| URL | Request | Response | Headers; // Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises. +// Arm ordering matters here: +// - `Promise` must come before `StubBase`: `RpcPromise` matches both, and must resolve +// through the Promise arm rather than pass through as-is. +// - `StubBase` must come before `Stubable`: `Stub` of a callable `T` is itself callable, so +// it matches `Stubable`. Checking `StubBase` first keeps existing stubs as-is instead of +// double-wrapping them as `Stub>`. +// prettier-ignore +type Stubify = T extends Promise ? Stubify : T extends StubBase ? T : T extends Stubable ? Stub : T extends Map ? Map, Stubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Stubify, ...Stubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Stubify, ...Stubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T // When using "unknown" instead of "any", interfaces are not stubified. +>Stubify : Stubify + +: T extends { + [key: string | number]: any; +>key : string | number + +} ? { [K in keyof T as K extends string | number ? K : never]: Stubify } : T; +// Recursively rewrite all `Stub`s with the corresponding `T`s. +// Note we use `StubBase` instead of `Stub` here to avoid circular dependencies: +// `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`. +// prettier-ignore +type UnstubifyInner = // Preserve local RpcTarget acceptance, but avoid needless `Stub | Value` unions when the stub +>UnstubifyInner : UnstubifyInner + +// is already assignable to the value type (important for callback contextual typing). +T extends StubBase ? (T extends V ? UnstubifyInner : (T | UnstubifyInner)) : T extends Promise ? UnstubifyInner : T extends Map ? Map, Unstubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Unstubify, ...Unstubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Unstubify, ...Unstubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T : T extends { + [key: string | number]: unknown; +>key : string | number + +} ? { [K in keyof T as K extends string | number ? K : never]: Unstubify } : T; // You can put promises anywhere in the params and they'll be resolved before delivery. +// (This also covers RpcPromise, because it's defined as being a Promise.) +// Map placeholders are also allowed so primitive map callback inputs can be forwarded directly +// into RPC params. +// +// Keep raw non-stub members so generic assignability still works when UnstubifyInner is deferred. +// Remove stub members from mixed unions so callback params don’t get both stub and unstubbed signatures. +// Marker carried by map() callback inputs. This lets primitive placeholders flow through params. +type Unstubify = NonStubMembers | UnstubifyInner | Promise> | MapValuePlaceholder>; +>Unstubify : Unstubify + +type UnstubifyAll = { [I in keyof A]: Unstubify }; +>UnstubifyAll : UnstubifyAll + +interface MapValuePlaceholder { + [__RPC_MAP_VALUE_BRAND]: T; +>[__RPC_MAP_VALUE_BRAND] : T +>__RPC_MAP_VALUE_BRAND : unique symbol +} +type NonStubMembers = Exclude>; // Utility type for adding `Disposable`s to `object` types only. +>NonStubMembers : NonStubMembers + +// Note `unknown & T` is equivalent to `T`. +type MaybeDisposable = T extends object ? Disposable : unknown; // The type behind the public `RpcPromise` (re-exported with its `RpcCompatible` constraint from +>MaybeDisposable : MaybeDisposable + +// index.ts). Defined here so that `Result`'s arms below resolve to the exact same alias +// instantiation: when both sides of an assignability check are the same alias applied to the +// same type arguments, the checker short-circuits on identity instead of recursing through the +// full structural comparison of these mutually-recursive types. +type RpcPromise$1 = T extends Stubable ? Promise> & Provider & StubBase : Promise & MaybeDisposable> & Provider & StubBase; +>RpcPromise$1 : RpcPromise$1 + +// The elision `Result` applies to a bare stub type: unwrap `Stub` back to `T` when the +// payload is `Stubable`. Such stubs await back to a stub either way, so eliding keeps a +// declared `Promise>` return interchangeable with a `Promise` return. +// Plain-interface stubs are NOT elided: `RpcPromise` only awaits to `Stub` when +// `U extends Stubable`, so eliding those would change the awaited type from a stub to a +// stubified record. The payload check is deliberately non-distributive (`[U] extends [...]`). +// `Stub` is not elided either: `[any] extends [Stubable]` is true, so without the `IsAny` +// guard an `any`-payload stub would lose its stub surface. +// Also used by the `RpcPromise` constructor signature (index.ts), which applies exactly this +// transformation so constructing from a promised stub matches the method-return type. +type ElideStub = T extends StubBase ? (IsAny extends true ? T : [U] extends [Stubable] ? U : T) : T; +>ElideStub : ElideStub +>true : true + +// What the promise given to `new RpcPromise(...)` may resolve to: the payload itself, or — +// for stubable payloads — a stub of it. `NoInfer` keeps the stub arm out of inference, so an +// inferred `T` is always the promise's own resolution type; the arm only matters when `T` is +// explicitly annotated (`new RpcPromise(promiseOfStub)`). Stubs of non-stubable +// payloads are deliberately rejected: `ElideStub` wouldn't elide those, so accepting one would +// claim the promise awaits to a stubified record while the runtime resolves to a stub. +type PayloadOrStub = T | NoInfer>>; +>PayloadOrStub : PayloadOrStub + +// Type for method return or property on an RPC interface. +// - Stubable types are replaced by stubs. +// - RpcCompatible types are passed by value, with stubable types replaced by stubs +// and a top-level `Disposer`. +// Everything else can't be passed over RPC. +// Technically, we use custom thenables here, but they quack like `Promise`s. +// Intersecting with `(Maybe)Provider` allows pipelining. +// prettier-ignore +type Result = IsAny extends true ? RpcPromise$1 // `RpcPromise`: always safe to normalize — `Result` is idempotent — so a declared +>Result : Result +>true : true + +// `RpcPromise` return produces the same type as a `Promise` return. +: R extends PromiseLike & StubBase ? Result // Bare stubs: elide per `ElideStub` above. Note there is no `RpcCompatible` re-check +// here: anything matching our `StubBase` was produced by machinery that already enforced +// the constraint, and re-evaluating `RpcCompatible` in this arm recurses through its +// `Stub` member back into `Result`, tripping TS2615 circularity errors in mapped +// types. +: R extends StubBase ? RpcPromise$1> : R extends RpcCompatible ? RpcPromise$1 : never; +type IsAny = 0 extends (1 & T) ? true : false; // Type for method or property on an RPC interface. +>IsAny : IsAny +>true : true +>false : false + +// For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s. +// Unwrapping `Stub`s allows calling with `Stubable` arguments. +// For properties, rewrite types to be `Result`s. +// In each case, unwrap `Promise`s. +type MethodOrProperty = V extends ((...args: infer P) => infer R) ? (...args: UnstubifyAll

) => Result> : Result>; // Type for the callable part of an `Provider` if `T` is callable. +>MethodOrProperty : MethodOrProperty +>args : P +>args : UnstubifyAll

+ +// This is intersected with methods/properties. +type MaybeCallableProvider = T extends ((...args: any[]) => any) ? MethodOrProperty : unknown; +>MaybeCallableProvider : MaybeCallableProvider +>args : any[] + +type TupleIndexKeys> = Extract; +>TupleIndexKeys : TupleIndexKeys + +type MapCallbackValue = // `Omit` removes call signatures, so re-intersect callable provider behavior. +>MapCallbackValue : MapCallbackValue + +T extends unknown ? Omit, keyof Promise> & MaybeCallableProvider & MapValuePlaceholder : never; +type InvalidNativePromiseInMapResult = T extends unknown ? InvalidNativePromiseInMapResultImpl : never; +>InvalidNativePromiseInMapResult : InvalidNativePromiseInMapResult + +type InvalidNativePromiseInMapResultImpl = [T] extends [Seen] ? never // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values. +>InvalidNativePromiseInMapResultImpl : InvalidNativePromiseInMapResultImpl + +: T extends StubBase ? never // Native thenables cannot be represented in map recordings, even when typed as PromiseLike. +: T extends PromiseLike ? T : T extends Map ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends Set ? InvalidNativePromiseInMapResult : T extends readonly [] ? never : T extends readonly [infer Head, ...infer Tail] ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends ReadonlyArray ? InvalidNativePromiseInMapResult : T extends { + [key: string | number]: unknown; +>key : string | number + +} ? InvalidNativePromiseInMapResult], Seen | T> : never; +type MapCallbackReturn = InvalidNativePromiseInMapResult extends never ? T : never; +>MapCallbackReturn : MapCallbackReturn + +type ArrayProvider = { [K in number]: MethodOrProperty } & { +>ArrayProvider : ArrayProvider + + map(callback: (elem: MapCallbackValue) => MapCallbackReturn): Result>; +>map : (callback: (elem: MapCallbackValue) => MapCallbackReturn) => Result> +>callback : (elem: MapCallbackValue) => MapCallbackReturn +>elem : MapCallbackValue + +}; +type TupleProvider> = { [K in TupleIndexKeys]: MethodOrProperty } & ArrayProvider; // Base type for all other types providing RPC-like interfaces. +>TupleProvider : TupleProvider + +// Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types. +// `__RPC_TARGET_BRAND` deliberately flows through the key mapping (as a `never` property) so +// stubs of branded targets stay assignable to workers-types' `Stubable`. Such stubs match our +// `Stubable` too — harmless, since all machinery checks `StubBase` before `Stubable`. +type Provider = MaybeCallableProvider & (T extends ReadonlyArray ? number extends T["length"] ? ArrayProvider : TupleProvider : { [K in Exclude>]: MethodOrProperty } & { +>Provider : Provider + + map(callback: (value: MapCallbackValue>) => MapCallbackReturn): Result>; +>map : (callback: (value: MapCallbackValue>) => MapCallbackReturn) => Result> +>callback : (value: MapCallbackValue>) => MapCallbackReturn +>value : MapCallbackValue> + +}); +export type RpcStub> = Stub; +>RpcStub : RpcStub + +=== main.ts === +import type { RpcStub } from "./capnweb"; +>RpcStub : RpcStub + +declare const api: RpcStub<{ sub(): Promise> }>; +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase; } & any & import("./capnweb").StubBase +>sub : () => Promise> + +export async function f() { +>f : () => Promise + + await api.sub(); +>await api.sub() : {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable +>api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase; } & any & import("./capnweb").StubBase +>sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase + + api.sub().then(s => s); +>api.sub().then(s => s) : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> +>api.sub().then : (callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable, TResult2 = never>(onfulfilled?: any | any | undefined, onrejected?: any | any | undefined) => Promise +>api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase; } & any & import("./capnweb").StubBase +>sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>then : (callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable, TResult2 = never>(onfulfilled?: any | any | undefined, onrejected?: any | any | undefined) => Promise +>s => s : (s: {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable) => any & any & Disposable +>s : {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable +>s : {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt new file mode 100644 index 0000000000000..67a74da6b9b6d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt @@ -0,0 +1,31 @@ +varianceCycleDiscardedDiagnostics.ts(14,33): error TS2339: Property 'foo' does not exist on type 'A'. + + +==== varianceCycleDiscardedDiagnostics.ts (1 errors) ==== + // Measuring the variances of Bar resolves the type of Value, which picks an + // overload by relating Foo to Foo while the variances of Bar are + // still being measured. Diagnostics from that attempt must not outlive it, + // and the result must not depend on whether Value or the variances of Bar + // are needed first. + + interface A { a: string } + interface B { foo: string } + declare function pick(x: Foo): A; + declare function pick(x: object): B; + + class Bar { + x!: T; + Value = pick(new Foo(this)).foo; + ~~~ +!!! error TS2339: Property 'foo' does not exist on type 'A'. + } + + class Foo { + bar!: Bar; + constructor(bar: Bar) { + this.bar = bar; + } + } + + const v: number = new Bar().Value; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols new file mode 100644 index 0000000000000..e08928ce4a02d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols @@ -0,0 +1,71 @@ +//// [tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts] //// + +=== varianceCycleDiscardedDiagnostics.ts === +// Measuring the variances of Bar resolves the type of Value, which picks an +// overload by relating Foo to Foo while the variances of Bar are +// still being measured. Diagnostics from that attempt must not outlive it, +// and the result must not depend on whether Value or the variances of Bar +// are needed first. + +interface A { a: string } +>A : Symbol(A, Decl(varianceCycleDiscardedDiagnostics.ts, 0, 0)) +>a : Symbol(A.a, Decl(varianceCycleDiscardedDiagnostics.ts, 6, 13)) + +interface B { foo: string } +>B : Symbol(B, Decl(varianceCycleDiscardedDiagnostics.ts, 6, 25)) +>foo : Symbol(B.foo, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 13)) + +declare function pick(x: Foo): A; +>pick : Symbol(pick, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 27), Decl(varianceCycleDiscardedDiagnostics.ts, 8, 41)) +>x : Symbol(x, Decl(varianceCycleDiscardedDiagnostics.ts, 8, 22)) +>Foo : Symbol(Foo, Decl(varianceCycleDiscardedDiagnostics.ts, 14, 1)) +>A : Symbol(A, Decl(varianceCycleDiscardedDiagnostics.ts, 0, 0)) + +declare function pick(x: object): B; +>pick : Symbol(pick, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 27), Decl(varianceCycleDiscardedDiagnostics.ts, 8, 41)) +>x : Symbol(x, Decl(varianceCycleDiscardedDiagnostics.ts, 9, 22)) +>B : Symbol(B, Decl(varianceCycleDiscardedDiagnostics.ts, 6, 25)) + +class Bar { +>Bar : Symbol(Bar, Decl(varianceCycleDiscardedDiagnostics.ts, 9, 36)) +>T : Symbol(T, Decl(varianceCycleDiscardedDiagnostics.ts, 11, 10)) + + x!: T; +>x : Symbol(Bar.x, Decl(varianceCycleDiscardedDiagnostics.ts, 11, 14)) +>T : Symbol(T, Decl(varianceCycleDiscardedDiagnostics.ts, 11, 10)) + + Value = pick(new Foo(this)).foo; +>Value : Symbol(Bar.Value, Decl(varianceCycleDiscardedDiagnostics.ts, 12, 10)) +>pick : Symbol(pick, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 27), Decl(varianceCycleDiscardedDiagnostics.ts, 8, 41)) +>Foo : Symbol(Foo, Decl(varianceCycleDiscardedDiagnostics.ts, 14, 1)) +>this : Symbol(Bar, Decl(varianceCycleDiscardedDiagnostics.ts, 9, 36)) +} + +class Foo { +>Foo : Symbol(Foo, Decl(varianceCycleDiscardedDiagnostics.ts, 14, 1)) +>T : Symbol(T, Decl(varianceCycleDiscardedDiagnostics.ts, 16, 10)) + + bar!: Bar; +>bar : Symbol(Foo.bar, Decl(varianceCycleDiscardedDiagnostics.ts, 16, 14)) +>Bar : Symbol(Bar, Decl(varianceCycleDiscardedDiagnostics.ts, 9, 36)) +>T : Symbol(T, Decl(varianceCycleDiscardedDiagnostics.ts, 16, 10)) + + constructor(bar: Bar) { +>bar : Symbol(bar, Decl(varianceCycleDiscardedDiagnostics.ts, 18, 16)) +>Bar : Symbol(Bar, Decl(varianceCycleDiscardedDiagnostics.ts, 9, 36)) +>T : Symbol(T, Decl(varianceCycleDiscardedDiagnostics.ts, 16, 10)) + + this.bar = bar; +>this.bar : Symbol(Foo.bar, Decl(varianceCycleDiscardedDiagnostics.ts, 16, 14)) +>this : Symbol(Foo, Decl(varianceCycleDiscardedDiagnostics.ts, 14, 1)) +>bar : Symbol(Foo.bar, Decl(varianceCycleDiscardedDiagnostics.ts, 16, 14)) +>bar : Symbol(bar, Decl(varianceCycleDiscardedDiagnostics.ts, 18, 16)) + } +} + +const v: number = new Bar().Value; +>v : Symbol(v, Decl(varianceCycleDiscardedDiagnostics.ts, 23, 5)) +>new Bar().Value : Symbol(Bar.Value, Decl(varianceCycleDiscardedDiagnostics.ts, 12, 10)) +>Bar : Symbol(Bar, Decl(varianceCycleDiscardedDiagnostics.ts, 9, 36)) +>Value : Symbol(Bar.Value, Decl(varianceCycleDiscardedDiagnostics.ts, 12, 10)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types new file mode 100644 index 0000000000000..ad994f6a17985 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types @@ -0,0 +1,65 @@ +//// [tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts] //// + +=== varianceCycleDiscardedDiagnostics.ts === +// Measuring the variances of Bar resolves the type of Value, which picks an +// overload by relating Foo to Foo while the variances of Bar are +// still being measured. Diagnostics from that attempt must not outlive it, +// and the result must not depend on whether Value or the variances of Bar +// are needed first. + +interface A { a: string } +>a : string + +interface B { foo: string } +>foo : string + +declare function pick(x: Foo): A; +>pick : { (x: Foo): A; (x: object): B; } +>x : Foo + +declare function pick(x: object): B; +>pick : { (x: Foo): A; (x: object): B; } +>x : object + +class Bar { +>Bar : Bar + + x!: T; +>x : T + + Value = pick(new Foo(this)).foo; +>Value : any +>pick(new Foo(this)).foo : any +>pick(new Foo(this)) : A +>pick : { (x: Foo): A; (x: object): B; } +>new Foo(this) : Foo +>Foo : typeof Foo +>this : this +>foo : any +} + +class Foo { +>Foo : Foo + + bar!: Bar; +>bar : Bar + + constructor(bar: Bar) { +>bar : Bar + + this.bar = bar; +>this.bar = bar : Bar +>this.bar : Bar +>this : this +>bar : Bar +>bar : Bar + } +} + +const v: number = new Bar().Value; +>v : number +>new Bar().Value : any +>new Bar() : Bar +>Bar : typeof Bar +>Value : any + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).symbols new file mode 100644 index 0000000000000..b6711c2e9b95b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).symbols @@ -0,0 +1,132 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) + + brand: T; +>brand : Symbol(StubBase.brand, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 33)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 38)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 70)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) + +function f(x: Stubify, y: Stubify) { +>f : Symbol(f, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 62)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) + + y = x; +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) + + x = y; +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) + +export async function g() { +>g : Symbol(g, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 54)) + + await api.sub(); +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) + + api.sub().then(s => s); +>api.sub().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).types new file mode 100644 index 0000000000000..41efe3567475b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { + brand: T; +>brand : T +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Stub + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Stubify + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : RpcPromise + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Result + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : MethodOrProperty +>args : P +>args : P + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Provider + +function f(x: Stubify, y: Stubify) { +>f : (x: Stubify, y: Stubify) => void +>x : Stubify +>y : Stubify | undefined + + y = x; +>y = x : Stubify +>y : Stubify | undefined +>x : Stubify + + x = y; +>x = y : Stubify +>x : Stubify +>y : Stubify +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => Promise> + +export async function g() { +>g : () => Promise + + await api.sub(); +>await api.sub() : {} +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> + + api.sub().then(s => s); +>api.sub().then(s => s) : Promise<{}> +>api.sub().then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> +>then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>s => s : (s: {}) => {} +>s : {} +>s : {} +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..b6711c2e9b95b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).symbols @@ -0,0 +1,132 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) + + brand: T; +>brand : Symbol(StubBase.brand, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 33)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 38)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 70)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) + +function f(x: Stubify, y: Stubify) { +>f : Symbol(f, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 62)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) + + y = x; +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) + + x = y; +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) + +export async function g() { +>g : Symbol(g, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 54)) + + await api.sub(); +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) + + api.sub().then(s => s); +>api.sub().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).types new file mode 100644 index 0000000000000..41efe3567475b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { + brand: T; +>brand : T +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Stub + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Stubify + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : RpcPromise + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Result + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : MethodOrProperty +>args : P +>args : P + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Provider + +function f(x: Stubify, y: Stubify) { +>f : (x: Stubify, y: Stubify) => void +>x : Stubify +>y : Stubify | undefined + + y = x; +>y = x : Stubify +>y : Stubify | undefined +>x : Stubify + + x = y; +>x = y : Stubify +>x : Stubify +>y : Stubify +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => Promise> + +export async function g() { +>g : () => Promise + + await api.sub(); +>await api.sub() : {} +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> + + api.sub().then(s => s); +>api.sub().then(s => s) : Promise<{}> +>api.sub().then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> +>then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>s => s : (s: {}) => {} +>s : {} +>s : {} +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.errors.txt new file mode 100644 index 0000000000000..3093fe2786a2e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.errors.txt @@ -0,0 +1,78 @@ +barFirst.ts(9,1): error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. + Type 'string' is not assignable to type '"lit"'. +barFirst.ts(10,1): error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +barFirst.ts(11,1): error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. + Types of property 'b' are incompatible. + Type 'Bar>' is not assignable to type 'Bar>'. + Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +fooFirst.ts(8,1): error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +fooFirst.ts(9,1): error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. + Types of property 'b' are incompatible. + Type 'Bar>' is not assignable to type 'Bar>'. + Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +fooFirst.ts(11,1): error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. + Type 'string' is not assignable to type '"lit"'. + + +==== fooFirst.ts (3 errors) ==== + export {}; + + interface Foo { x: T; b: Bar> } + interface Bar { f: (u: U) => void; foo: Foo> } + + declare let fs: Foo, fl: Foo<"lit">; + declare let bs: Bar, bl: Bar<"lit">; + fl = fs; // Error + ~~ +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + fs = fl; // Error + ~~ +!!! error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'Bar>' is not assignable to type 'Bar>'. +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + bl = bs; // Error + bs = bl; // Error + ~~ +!!! error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + +==== barFirst.ts (3 errors) ==== + export {}; + + interface Foo { x: T; b: Bar> } + interface Bar { f: (u: U) => void; foo: Foo> } + + declare let fs: Foo, fl: Foo<"lit">; + declare let bs: Bar, bl: Bar<"lit">; + bl = bs; // Error + bs = bl; // Error + ~~ +!!! error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + fl = fs; // Error + ~~ +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + fs = fl; // Error + ~~ +!!! error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'Bar>' is not assignable to type 'Bar>'. +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.symbols new file mode 100644 index 0000000000000..478f02d4a04a7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/varianceCycleEntryOrder.ts] //// + +=== fooFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>T : Symbol(T, Decl(fooFirst.ts, 2, 14)) +>x : Symbol(Foo.x, Decl(fooFirst.ts, 2, 18)) +>T : Symbol(T, Decl(fooFirst.ts, 2, 14)) +>b : Symbol(Foo.b, Decl(fooFirst.ts, 2, 24)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>T : Symbol(T, Decl(fooFirst.ts, 2, 14)) + +interface Bar { f: (u: U) => void; foo: Foo> } +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>U : Symbol(U, Decl(fooFirst.ts, 3, 14)) +>f : Symbol(Bar.f, Decl(fooFirst.ts, 3, 18)) +>u : Symbol(u, Decl(fooFirst.ts, 3, 23)) +>U : Symbol(U, Decl(fooFirst.ts, 3, 14)) +>foo : Symbol(Bar.foo, Decl(fooFirst.ts, 3, 37)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>U : Symbol(U, Decl(fooFirst.ts, 3, 14)) + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Symbol(fs, Decl(fooFirst.ts, 5, 11)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>fl : Symbol(fl, Decl(fooFirst.ts, 5, 28)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Symbol(bs, Decl(fooFirst.ts, 6, 11)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>bl : Symbol(bl, Decl(fooFirst.ts, 6, 28)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) + +fl = fs; // Error +>fl : Symbol(fl, Decl(fooFirst.ts, 5, 28)) +>fs : Symbol(fs, Decl(fooFirst.ts, 5, 11)) + +fs = fl; // Error +>fs : Symbol(fs, Decl(fooFirst.ts, 5, 11)) +>fl : Symbol(fl, Decl(fooFirst.ts, 5, 28)) + +bl = bs; // Error +>bl : Symbol(bl, Decl(fooFirst.ts, 6, 28)) +>bs : Symbol(bs, Decl(fooFirst.ts, 6, 11)) + +bs = bl; // Error +>bs : Symbol(bs, Decl(fooFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(fooFirst.ts, 6, 28)) + +=== barFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>T : Symbol(T, Decl(barFirst.ts, 2, 14)) +>x : Symbol(Foo.x, Decl(barFirst.ts, 2, 18)) +>T : Symbol(T, Decl(barFirst.ts, 2, 14)) +>b : Symbol(Foo.b, Decl(barFirst.ts, 2, 24)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>T : Symbol(T, Decl(barFirst.ts, 2, 14)) + +interface Bar { f: (u: U) => void; foo: Foo> } +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>U : Symbol(U, Decl(barFirst.ts, 3, 14)) +>f : Symbol(Bar.f, Decl(barFirst.ts, 3, 18)) +>u : Symbol(u, Decl(barFirst.ts, 3, 23)) +>U : Symbol(U, Decl(barFirst.ts, 3, 14)) +>foo : Symbol(Bar.foo, Decl(barFirst.ts, 3, 37)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>U : Symbol(U, Decl(barFirst.ts, 3, 14)) + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Symbol(fs, Decl(barFirst.ts, 5, 11)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>fl : Symbol(fl, Decl(barFirst.ts, 5, 28)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Symbol(bs, Decl(barFirst.ts, 6, 11)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>bl : Symbol(bl, Decl(barFirst.ts, 6, 28)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) + +bl = bs; // Error +>bl : Symbol(bl, Decl(barFirst.ts, 6, 28)) +>bs : Symbol(bs, Decl(barFirst.ts, 6, 11)) + +bs = bl; // Error +>bs : Symbol(bs, Decl(barFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(barFirst.ts, 6, 28)) + +fl = fs; // Error +>fl : Symbol(fl, Decl(barFirst.ts, 5, 28)) +>fs : Symbol(fs, Decl(barFirst.ts, 5, 11)) + +fs = fl; // Error +>fs : Symbol(fs, Decl(barFirst.ts, 5, 11)) +>fl : Symbol(fl, Decl(barFirst.ts, 5, 28)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.types b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.types new file mode 100644 index 0000000000000..3e1522dd51543 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.types @@ -0,0 +1,82 @@ +//// [tests/cases/compiler/varianceCycleEntryOrder.ts] //// + +=== fooFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>x : T +>b : Bar> + +interface Bar { f: (u: U) => void; foo: Foo> } +>f : (u: U) => void +>u : U +>foo : Foo> + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Foo +>fl : Foo<"lit"> + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Bar +>bl : Bar<"lit"> + +fl = fs; // Error +>fl = fs : Foo +>fl : Foo<"lit"> +>fs : Foo + +fs = fl; // Error +>fs = fl : Foo<"lit"> +>fs : Foo +>fl : Foo<"lit"> + +bl = bs; // Error +>bl = bs : Bar +>bl : Bar<"lit"> +>bs : Bar + +bs = bl; // Error +>bs = bl : Bar<"lit"> +>bs : Bar +>bl : Bar<"lit"> + +=== barFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>x : T +>b : Bar> + +interface Bar { f: (u: U) => void; foo: Foo> } +>f : (u: U) => void +>u : U +>foo : Foo> + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Foo +>fl : Foo<"lit"> + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Bar +>bl : Bar<"lit"> + +bl = bs; // Error +>bl = bs : Bar +>bl : Bar<"lit"> +>bs : Bar + +bs = bl; // Error +>bs = bl : Bar<"lit"> +>bs : Bar +>bl : Bar<"lit"> + +fl = fs; // Error +>fl = fs : Foo +>fl : Foo<"lit"> +>fs : Foo + +fs = fl; // Error +>fs = fl : Foo<"lit"> +>fs : Foo +>fl : Foo<"lit"> + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.symbols new file mode 100644 index 0000000000000..eb4907af8e1b1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.symbols @@ -0,0 +1,999 @@ +//// [tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts] //// + +=== json-logic-js.d.ts === +export as namespace jsonFactory; +>jsonFactory : Symbol(jsonFactory, Decl(json-logic-js.d.ts, 0, 0)) + +// Disable auto-export +export {}; + +type RenameToIn = { +>RenameToIn : Symbol(RenameToIn, Decl(json-logic-js.d.ts, 3, 10)) +>T : Symbol(T, Decl(json-logic-js.d.ts, 5, 16)) + + [K in keyof T as K extends `in${Uppercase}${Lowercase}` ? `in` : K]: T[K]; +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) +>T : Symbol(T, Decl(json-logic-js.d.ts, 5, 16)) +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) +>T : Symbol(T, Decl(json-logic-js.d.ts, 5, 16)) +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) + +}; + +/** + * This is a utility type used below for the "if" operation. + * Original: https://stackoverflow.com/a/68373774/765987 + */ +type MAXIMUM_ALLOWED_BOUNDARY = 80; +>MAXIMUM_ALLOWED_BOUNDARY : Symbol(MAXIMUM_ALLOWED_BOUNDARY, Decl(json-logic-js.d.ts, 7, 2)) + +type Mapped< +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) + + Tuple extends unknown[], +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) + + Result extends unknown[] = [], +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) + + Count extends readonly number[] = [], +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) + +> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) +>MAXIMUM_ALLOWED_BOUNDARY : Symbol(MAXIMUM_ALLOWED_BOUNDARY, Decl(json-logic-js.d.ts, 7, 2)) +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) + + : Tuple extends [] ? [] +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) + + : Result extends [] ? Mapped +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) + + : Mapped; +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) + +/** + * Used for the "if" operation, which takes an array of odd length + * and a minimum of three (3) elements. + */ +type AnyArrayOfOddLengthMin3 = [any, ...Mapped<[any, any]>]; +>AnyArrayOfOddLengthMin3 : Symbol(AnyArrayOfOddLengthMin3, Decl(json-logic-js.d.ts, 21, 67)) +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) + +export type ReservedOperations = +>ReservedOperations : Symbol(ReservedOperations, Decl(json-logic-js.d.ts, 26, 60)) + + | "var" + | "missing" + | "missing_some" + | "if" + | "==" + | "===" + | "!=" + | "!==" + | "!" + | "!!" + | "or" + | "and" + | ">" + | ">=" + | "<" + | "<=" + | "max" + | "min" + | "+" + | "-" + | "*" + | "/" + | "%" + | "map" + | "filter" + | "reduce" + | "all" + | "none" + | "some" + | "merge" + | "in" + | "cat" + | "substr" + | "log"; + +/** + * This can be an object with any key except the reserved keys. + * TODO: Find a way to limit this type to exactly one (1) key, since + * json-logic-js enforces it. See: + * https://github.com/jwadhams/json-logic-js/blob/2.0.2/logic.js#L180 + */ +export type AdditionalOperation = Partial> & { [k: string]: any }; +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>ReservedOperations : Symbol(ReservedOperations, Decl(json-logic-js.d.ts, 26, 60)) +>k : Symbol(k, Decl(json-logic-js.d.ts, 70, 82)) + +export interface AllReservedOperationsInterface { +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) + + var: RulesLogic | [RulesLogic] | [RulesLogic, any] | [RulesLogic, any]; +>var : Symbol(AllReservedOperationsInterface.var, Decl(json-logic-js.d.ts, 72, 93)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + missing: RulesLogic | any[]; +>missing : Symbol(AllReservedOperationsInterface.missing, Decl(json-logic-js.d.ts, 73, 107)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + missing_some: [RulesLogic, RulesLogic | any[]]; +>missing_some : Symbol(AllReservedOperationsInterface.missing_some, Decl(json-logic-js.d.ts, 74, 40)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + if: AnyArrayOfOddLengthMin3; +>if : Symbol(AllReservedOperationsInterface.if, Decl(json-logic-js.d.ts, 75, 67)) +>AnyArrayOfOddLengthMin3 : Symbol(AnyArrayOfOddLengthMin3, Decl(json-logic-js.d.ts, 21, 67)) + + "==": [any, any]; +>"==" : Symbol(AllReservedOperationsInterface["=="], Decl(json-logic-js.d.ts, 76, 32)) + + "===": [any, any]; +>"===" : Symbol(AllReservedOperationsInterface["==="], Decl(json-logic-js.d.ts, 77, 21)) + + "!=": [any, any]; +>"!=" : Symbol(AllReservedOperationsInterface["!="], Decl(json-logic-js.d.ts, 78, 22)) + + "!==": [any, any]; +>"!==" : Symbol(AllReservedOperationsInterface["!=="], Decl(json-logic-js.d.ts, 79, 21)) + + "!": any; +>"!" : Symbol(AllReservedOperationsInterface["!"], Decl(json-logic-js.d.ts, 80, 22)) + + "!!": any; +>"!!" : Symbol(AllReservedOperationsInterface["!!"], Decl(json-logic-js.d.ts, 81, 13)) + + or: Array>; +>or : Symbol(AllReservedOperationsInterface.or, Decl(json-logic-js.d.ts, 82, 14)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + and: Array>; +>and : Symbol(AllReservedOperationsInterface.and, Decl(json-logic-js.d.ts, 83, 34)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + ">": [RulesLogic, RulesLogic]; +>">" : Symbol(AllReservedOperationsInterface[">"], Decl(json-logic-js.d.ts, 84, 35)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + ">=": [RulesLogic, RulesLogic]; +>">=" : Symbol(AllReservedOperationsInterface[">="], Decl(json-logic-js.d.ts, 85, 50)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "<": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<" : Symbol(AllReservedOperationsInterface["<"], Decl(json-logic-js.d.ts, 86, 51)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "<=": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<=" : Symbol(AllReservedOperationsInterface["<="], Decl(json-logic-js.d.ts, 87, 113)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + max: Array>; +>max : Symbol(AllReservedOperationsInterface.max, Decl(json-logic-js.d.ts, 88, 114)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + min: Array>; +>min : Symbol(AllReservedOperationsInterface.min, Decl(json-logic-js.d.ts, 89, 35)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "+": Array> | RulesLogic; +>"+" : Symbol(AllReservedOperationsInterface["+"], Decl(json-logic-js.d.ts, 90, 35)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "-": Array> | RulesLogic; +>"-" : Symbol(AllReservedOperationsInterface["-"], Decl(json-logic-js.d.ts, 91, 56)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "*": Array> | RulesLogic; +>"*" : Symbol(AllReservedOperationsInterface["*"], Decl(json-logic-js.d.ts, 92, 56)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "/": Array> | RulesLogic; +>"/" : Symbol(AllReservedOperationsInterface["/"], Decl(json-logic-js.d.ts, 93, 56)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "%": [RulesLogic, RulesLogic]; +>"%" : Symbol(AllReservedOperationsInterface["%"], Decl(json-logic-js.d.ts, 94, 56)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + map: [RulesLogic, RulesLogic]; +>map : Symbol(AllReservedOperationsInterface.map, Decl(json-logic-js.d.ts, 95, 50)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + filter: [RulesLogic, RulesLogic]; +>filter : Symbol(AllReservedOperationsInterface.filter, Decl(json-logic-js.d.ts, 96, 50)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + reduce: [RulesLogic, RulesLogic, RulesLogic]; +>reduce : Symbol(AllReservedOperationsInterface.reduce, Decl(json-logic-js.d.ts, 97, 53)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + all: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>all : Symbol(AllReservedOperationsInterface.all, Decl(json-logic-js.d.ts, 98, 73)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + none: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>none : Symbol(AllReservedOperationsInterface.none, Decl(json-logic-js.d.ts, 99, 100)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + some: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>some : Symbol(AllReservedOperationsInterface.some, Decl(json-logic-js.d.ts, 100, 101)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + merge: Array> | RulesLogic>; +>merge : Symbol(AllReservedOperationsInterface.merge, Decl(json-logic-js.d.ts, 101, 101)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + inArray: [RulesLogic, Array>]; +>inArray : Symbol(AllReservedOperationsInterface.inArray, Decl(json-logic-js.d.ts, 102, 65)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + inString: [RulesLogic, RulesLogic]; +>inString : Symbol(AllReservedOperationsInterface.inString, Decl(json-logic-js.d.ts, 103, 61)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + cat: Array>; +>cat : Symbol(AllReservedOperationsInterface.cat, Decl(json-logic-js.d.ts, 104, 55)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + substr: [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>substr : Symbol(AllReservedOperationsInterface.substr, Decl(json-logic-js.d.ts, 105, 35)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + log: RulesLogic; +>log : Symbol(AllReservedOperationsInterface.log, Decl(json-logic-js.d.ts, 106, 116)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +} + +export type JsonLogicVar = Pick< +>JsonLogicVar : Symbol(JsonLogicVar, Decl(json-logic-js.d.ts, 108, 1)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 110, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 110, 25)) + + "var" +>; +export type JsonLogicMissing = Pick< +>JsonLogicMissing : Symbol(JsonLogicMissing, Decl(json-logic-js.d.ts, 113, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 114, 29)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 114, 29)) + + "missing" +>; +export type JsonLogicMissingSome = Pick< +>JsonLogicMissingSome : Symbol(JsonLogicMissingSome, Decl(json-logic-js.d.ts, 117, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 118, 33)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 118, 33)) + + "missing_some" +>; +export type JsonLogicIf = Pick; +>JsonLogicIf : Symbol(JsonLogicIf, Decl(json-logic-js.d.ts, 121, 2)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicEqual = Pick; +>JsonLogicEqual : Symbol(JsonLogicEqual, Decl(json-logic-js.d.ts, 122, 69)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicStrictEqual = Pick; +>JsonLogicStrictEqual : Symbol(JsonLogicStrictEqual, Decl(json-logic-js.d.ts, 123, 72)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicNotEqual = Pick; +>JsonLogicStrictNotEqual : Symbol(JsonLogicStrictNotEqual, Decl(json-logic-js.d.ts, 125, 75)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicNegation = Pick; +>JsonLogicNegation : Symbol(JsonLogicNegation, Decl(json-logic-js.d.ts, 126, 82)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicDoubleNegation = Pick; +>JsonLogicDoubleNegation : Symbol(JsonLogicDoubleNegation, Decl(json-logic-js.d.ts, 127, 74)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicOr = Pick< +>JsonLogicOr : Symbol(JsonLogicOr, Decl(json-logic-js.d.ts, 128, 81)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 129, 24)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 129, 24)) + + "or" +>; +export type JsonLogicAnd = Pick< +>JsonLogicAnd : Symbol(JsonLogicAnd, Decl(json-logic-js.d.ts, 132, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 133, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 133, 25)) + + "and" +>; +export type JsonLogicGreaterThan = Pick< +>JsonLogicGreaterThan : Symbol(JsonLogicGreaterThan, Decl(json-logic-js.d.ts, 136, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 137, 33)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 137, 33)) + + ">" +>; +export type JsonLogicGreaterThanOrEqual = Pick< +>JsonLogicGreaterThanOrEqual : Symbol(JsonLogicGreaterThanOrEqual, Decl(json-logic-js.d.ts, 140, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 141, 40)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 141, 40)) + + ">=" +>; +export type JsonLogicLessThan = Pick< +>JsonLogicLessThan : Symbol(JsonLogicLessThan, Decl(json-logic-js.d.ts, 144, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 145, 30)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 145, 30)) + + "<" +>; +export type JsonLogicLessThanOrEqual = Pick< +>JsonLogicLessThanOrEqual : Symbol(JsonLogicLessThanOrEqual, Decl(json-logic-js.d.ts, 148, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 149, 37)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 149, 37)) + + "<=" +>; +export type JsonLogicMax = Pick< +>JsonLogicMax : Symbol(JsonLogicMax, Decl(json-logic-js.d.ts, 152, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 153, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 153, 25)) + + "max" +>; +export type JsonLogicMin = Pick< +>JsonLogicMin : Symbol(JsonLogicMin, Decl(json-logic-js.d.ts, 156, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 157, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 157, 25)) + + "min" +>; +export type JsonLogicSum = Pick< +>JsonLogicSum : Symbol(JsonLogicSum, Decl(json-logic-js.d.ts, 160, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 161, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 161, 25)) + + "+" +>; +export type JsonLogicDifference = Pick< +>JsonLogicDifference : Symbol(JsonLogicDifference, Decl(json-logic-js.d.ts, 164, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 165, 32)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 165, 32)) + + "-" +>; +export type JsonLogicProduct = Pick< +>JsonLogicProduct : Symbol(JsonLogicProduct, Decl(json-logic-js.d.ts, 168, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 169, 29)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 169, 29)) + + "*" +>; +export type JsonLogicQuotient = Pick< +>JsonLogicQuotient : Symbol(JsonLogicQuotient, Decl(json-logic-js.d.ts, 172, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 173, 30)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 173, 30)) + + "/" +>; +export type JsonLogicRemainder = Pick< +>JsonLogicRemainder : Symbol(JsonLogicRemainder, Decl(json-logic-js.d.ts, 176, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 177, 31)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 177, 31)) + + "%" +>; +export type JsonLogicMap = Pick< +>JsonLogicMap : Symbol(JsonLogicMap, Decl(json-logic-js.d.ts, 180, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 181, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 181, 25)) + + "map" +>; +export type JsonLogicFilter = Pick< +>JsonLogicFilter : Symbol(JsonLogicFilter, Decl(json-logic-js.d.ts, 184, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 185, 28)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 185, 28)) + + "filter" +>; +export type JsonLogicReduce = Pick< +>JsonLogicReduce : Symbol(JsonLogicReduce, Decl(json-logic-js.d.ts, 188, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 189, 28)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 189, 28)) + + "reduce" +>; +export type JsonLogicAll = Pick< +>JsonLogicAll : Symbol(JsonLogicAll, Decl(json-logic-js.d.ts, 192, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 193, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 193, 25)) + + "all" +>; +export type JsonLogicNone = Pick< +>JsonLogicNone : Symbol(JsonLogicNone, Decl(json-logic-js.d.ts, 196, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 197, 26)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 197, 26)) + + "none" +>; +export type JsonLogicSome = Pick< +>JsonLogicSome : Symbol(JsonLogicSome, Decl(json-logic-js.d.ts, 200, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 201, 26)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 201, 26)) + + "some" +>; +export type JsonLogicMerge = Pick< +>JsonLogicMerge : Symbol(JsonLogicMerge, Decl(json-logic-js.d.ts, 204, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 205, 27)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 205, 27)) + + "merge" +>; +export type JsonLogicInArray = RenameToIn< +>JsonLogicInArray : Symbol(JsonLogicInArray, Decl(json-logic-js.d.ts, 208, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 209, 29)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>RenameToIn : Symbol(RenameToIn, Decl(json-logic-js.d.ts, 3, 10)) + + Pick, "inArray"> +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 209, 29)) + +>; +export type JsonLogicInString = RenameToIn< +>JsonLogicInString : Symbol(JsonLogicInString, Decl(json-logic-js.d.ts, 211, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 212, 30)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>RenameToIn : Symbol(RenameToIn, Decl(json-logic-js.d.ts, 3, 10)) + + Pick, "inString"> +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 212, 30)) + +>; +export type JsonLogicCat = Pick< +>JsonLogicCat : Symbol(JsonLogicCat, Decl(json-logic-js.d.ts, 214, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 215, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 215, 25)) + + "cat" +>; +export type JsonLogicSubstr = Pick< +>JsonLogicSubstr : Symbol(JsonLogicSubstr, Decl(json-logic-js.d.ts, 218, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 219, 28)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 219, 28)) + + "substr" +>; +export type JsonLogicLog = Pick< +>JsonLogicLog : Symbol(JsonLogicLog, Decl(json-logic-js.d.ts, 222, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 223, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 223, 25)) + + "log" +>; + +export type RulesLogic = +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) + + | boolean + | string + | number + | null + // Accessing Data - https://jsonlogic.com/operations.html#accessing-data + | JsonLogicVar +>JsonLogicVar : Symbol(JsonLogicVar, Decl(json-logic-js.d.ts, 108, 1)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMissing +>JsonLogicMissing : Symbol(JsonLogicMissing, Decl(json-logic-js.d.ts, 113, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMissingSome +>JsonLogicMissingSome : Symbol(JsonLogicMissingSome, Decl(json-logic-js.d.ts, 117, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Logic and Boolean Operations - https://jsonlogic.com/operations.html#logic-and-boolean-operations + | JsonLogicIf +>JsonLogicIf : Symbol(JsonLogicIf, Decl(json-logic-js.d.ts, 121, 2)) + + | JsonLogicEqual +>JsonLogicEqual : Symbol(JsonLogicEqual, Decl(json-logic-js.d.ts, 122, 69)) + + | JsonLogicStrictEqual +>JsonLogicStrictEqual : Symbol(JsonLogicStrictEqual, Decl(json-logic-js.d.ts, 123, 72)) + + | JsonLogicNotEqual +>JsonLogicNotEqual : Symbol(JsonLogicNotEqual, Decl(json-logic-js.d.ts, 124, 79)) + + | JsonLogicStrictNotEqual +>JsonLogicStrictNotEqual : Symbol(JsonLogicStrictNotEqual, Decl(json-logic-js.d.ts, 125, 75)) + + | JsonLogicNegation +>JsonLogicNegation : Symbol(JsonLogicNegation, Decl(json-logic-js.d.ts, 126, 82)) + + | JsonLogicDoubleNegation +>JsonLogicDoubleNegation : Symbol(JsonLogicDoubleNegation, Decl(json-logic-js.d.ts, 127, 74)) + + | JsonLogicOr +>JsonLogicOr : Symbol(JsonLogicOr, Decl(json-logic-js.d.ts, 128, 81)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicAnd +>JsonLogicAnd : Symbol(JsonLogicAnd, Decl(json-logic-js.d.ts, 132, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Numeric Operations - https://jsonlogic.com/operations.html#numeric-operations + | JsonLogicGreaterThan +>JsonLogicGreaterThan : Symbol(JsonLogicGreaterThan, Decl(json-logic-js.d.ts, 136, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicGreaterThanOrEqual +>JsonLogicGreaterThanOrEqual : Symbol(JsonLogicGreaterThanOrEqual, Decl(json-logic-js.d.ts, 140, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicLessThan +>JsonLogicLessThan : Symbol(JsonLogicLessThan, Decl(json-logic-js.d.ts, 144, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicLessThanOrEqual +>JsonLogicLessThanOrEqual : Symbol(JsonLogicLessThanOrEqual, Decl(json-logic-js.d.ts, 148, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMax +>JsonLogicMax : Symbol(JsonLogicMax, Decl(json-logic-js.d.ts, 152, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMin +>JsonLogicMin : Symbol(JsonLogicMin, Decl(json-logic-js.d.ts, 156, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicSum +>JsonLogicSum : Symbol(JsonLogicSum, Decl(json-logic-js.d.ts, 160, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicDifference +>JsonLogicDifference : Symbol(JsonLogicDifference, Decl(json-logic-js.d.ts, 164, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicProduct +>JsonLogicProduct : Symbol(JsonLogicProduct, Decl(json-logic-js.d.ts, 168, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicQuotient +>JsonLogicQuotient : Symbol(JsonLogicQuotient, Decl(json-logic-js.d.ts, 172, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicRemainder +>JsonLogicRemainder : Symbol(JsonLogicRemainder, Decl(json-logic-js.d.ts, 176, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Array Operations - https://jsonlogic.com/operations.html#array-operations + | JsonLogicMap +>JsonLogicMap : Symbol(JsonLogicMap, Decl(json-logic-js.d.ts, 180, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicFilter +>JsonLogicFilter : Symbol(JsonLogicFilter, Decl(json-logic-js.d.ts, 184, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicReduce +>JsonLogicReduce : Symbol(JsonLogicReduce, Decl(json-logic-js.d.ts, 188, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicAll +>JsonLogicAll : Symbol(JsonLogicAll, Decl(json-logic-js.d.ts, 192, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicNone +>JsonLogicNone : Symbol(JsonLogicNone, Decl(json-logic-js.d.ts, 196, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicSome +>JsonLogicSome : Symbol(JsonLogicSome, Decl(json-logic-js.d.ts, 200, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMerge +>JsonLogicMerge : Symbol(JsonLogicMerge, Decl(json-logic-js.d.ts, 204, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicInArray +>JsonLogicInArray : Symbol(JsonLogicInArray, Decl(json-logic-js.d.ts, 208, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // String Operations - https://jsonlogic.com/operations.html#string-operations + | JsonLogicInString +>JsonLogicInString : Symbol(JsonLogicInString, Decl(json-logic-js.d.ts, 211, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicCat +>JsonLogicCat : Symbol(JsonLogicCat, Decl(json-logic-js.d.ts, 214, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicSubstr +>JsonLogicSubstr : Symbol(JsonLogicSubstr, Decl(json-logic-js.d.ts, 218, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Miscellaneous - https://jsonlogic.com/operations.html#miscellaneous + | JsonLogicLog +>JsonLogicLog : Symbol(JsonLogicLog, Decl(json-logic-js.d.ts, 222, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Adding Operations (https://jsonlogic.com/add_operation.html) + | AddOps; +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + +export function add_operation(name: string, code: (...args: any[]) => any): void; +>add_operation : Symbol(add_operation, Decl(json-logic-js.d.ts, 275, 13)) +>name : Symbol(name, Decl(json-logic-js.d.ts, 277, 30)) +>code : Symbol(code, Decl(json-logic-js.d.ts, 277, 43)) +>args : Symbol(args, Decl(json-logic-js.d.ts, 277, 51)) + +export function apply(logic: RulesLogic, data?: unknown): any; +>apply : Symbol(apply, Decl(json-logic-js.d.ts, 277, 81)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 278, 22)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>data : Symbol(data, Decl(json-logic-js.d.ts, 278, 61)) + +export function rm_operation(name: string): void; +>rm_operation : Symbol(rm_operation, Decl(json-logic-js.d.ts, 278, 83)) +>name : Symbol(name, Decl(json-logic-js.d.ts, 279, 29)) + +// These functions are undocumented, but are exported by the real package +// so they're typed here for completeness. +export function is_logic(logic: any): logic is RulesLogic; +>is_logic : Symbol(is_logic, Decl(json-logic-js.d.ts, 279, 49)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 283, 25)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 283, 25)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) + +export function truthy(value: any): boolean; +>truthy : Symbol(truthy, Decl(json-logic-js.d.ts, 283, 58)) +>value : Symbol(value, Decl(json-logic-js.d.ts, 284, 23)) + +export function get_operator(logic: Record): string; +>get_operator : Symbol(get_operator, Decl(json-logic-js.d.ts, 284, 44)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 285, 29)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +export function get_values(logic: Record): any; +>get_values : Symbol(get_values, Decl(json-logic-js.d.ts, 285, 65)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 286, 27)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +export function uses_data(logic: Record): any[]; +>uses_data : Symbol(uses_data, Decl(json-logic-js.d.ts, 286, 60)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 287, 26)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +export function rule_like(rule: any, pattern: any): boolean; +>rule_like : Symbol(rule_like, Decl(json-logic-js.d.ts, 287, 61)) +>rule : Symbol(rule, Decl(json-logic-js.d.ts, 288, 26)) +>pattern : Symbol(pattern, Decl(json-logic-js.d.ts, 288, 36)) + +=== main.ts === +import * as jsonLogic from "./json-logic-js"; +>jsonLogic : Symbol(jsonLogic, Decl(main.ts, 0, 6)) + +type StartsWithAndEndsWith = +>StartsWithAndEndsWith : Symbol(StartsWithAndEndsWith, Decl(main.ts, 0, 45)) + + | { startsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] } +>startsWith : Symbol(startsWith, Decl(main.ts, 3, 7)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) + + | { endsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] }; +>endsWith : Symbol(endsWith, Decl(main.ts, 4, 7)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) + +type JsonLogicWithAdditionalOperations = jsonLogic.RulesLogic; +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) +>jsonLogic : Symbol(jsonLogic, Decl(main.ts, 0, 6)) +>RulesLogic : Symbol(jsonLogic.RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>StartsWithAndEndsWith : Symbol(StartsWithAndEndsWith, Decl(main.ts, 0, 45)) + +const jsonExtendedLogic: JsonLogicWithAdditionalOperations = { +>jsonExtendedLogic : Symbol(jsonExtendedLogic, Decl(main.ts, 6, 5)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) + + and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }], +>and : Symbol(and, Decl(main.ts, 6, 62)) +>startsWith : Symbol(startsWith, Decl(main.ts, 7, 11)) +>endsWith : Symbol(endsWith, Decl(main.ts, 7, 54)) + +}; +jsonLogic.apply(jsonExtendedLogic); +>jsonLogic.apply : Symbol(jsonLogic.apply, Decl(json-logic-js.d.ts, 277, 81)) +>jsonLogic : Symbol(jsonLogic, Decl(main.ts, 0, 6)) +>apply : Symbol(jsonLogic.apply, Decl(json-logic-js.d.ts, 277, 81)) +>jsonExtendedLogic : Symbol(jsonExtendedLogic, Decl(main.ts, 6, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.types b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.types new file mode 100644 index 0000000000000..0d5ee0db7b1f7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.types @@ -0,0 +1,518 @@ +//// [tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts] //// + +=== json-logic-js.d.ts === +export as namespace jsonFactory; +>jsonFactory : typeof import("./json-logic-js") + +// Disable auto-export +export {}; + +type RenameToIn = { +>RenameToIn : RenameToIn + + [K in keyof T as K extends `in${Uppercase}${Lowercase}` ? `in` : K]: T[K]; +}; + +/** + * This is a utility type used below for the "if" operation. + * Original: https://stackoverflow.com/a/68373774/765987 + */ +type MAXIMUM_ALLOWED_BOUNDARY = 80; +>MAXIMUM_ALLOWED_BOUNDARY : 80 + +type Mapped< +>Mapped : Mapped + + Tuple extends unknown[], + Result extends unknown[] = [], + Count extends readonly number[] = [], +> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result + : Tuple extends [] ? [] + : Result extends [] ? Mapped + : Mapped; +/** + * Used for the "if" operation, which takes an array of odd length + * and a minimum of three (3) elements. + */ +type AnyArrayOfOddLengthMin3 = [any, ...Mapped<[any, any]>]; +>AnyArrayOfOddLengthMin3 : [any, any, any] | [any, any, any, any, any] | [any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +export type ReservedOperations = +>ReservedOperations : ReservedOperations + + | "var" + | "missing" + | "missing_some" + | "if" + | "==" + | "===" + | "!=" + | "!==" + | "!" + | "!!" + | "or" + | "and" + | ">" + | ">=" + | "<" + | "<=" + | "max" + | "min" + | "+" + | "-" + | "*" + | "/" + | "%" + | "map" + | "filter" + | "reduce" + | "all" + | "none" + | "some" + | "merge" + | "in" + | "cat" + | "substr" + | "log"; + +/** + * This can be an object with any key except the reserved keys. + * TODO: Find a way to limit this type to exactly one (1) key, since + * json-logic-js enforces it. See: + * https://github.com/jwadhams/json-logic-js/blob/2.0.2/logic.js#L180 + */ +export type AdditionalOperation = Partial> & { [k: string]: any }; +>AdditionalOperation : AdditionalOperation +>k : string + +export interface AllReservedOperationsInterface { + var: RulesLogic | [RulesLogic] | [RulesLogic, any] | [RulesLogic, any]; +>var : [RulesLogic] | [RulesLogic, any] | RulesLogic + + missing: RulesLogic | any[]; +>missing : any[] | RulesLogic + + missing_some: [RulesLogic, RulesLogic | any[]]; +>missing_some : [RulesLogic, any[] | RulesLogic] + + if: AnyArrayOfOddLengthMin3; +>if : [any, any, any] | [any, any, any, any, any] | [any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + + "==": [any, any]; +>"==" : [any, any] + + "===": [any, any]; +>"===" : [any, any] + + "!=": [any, any]; +>"!=" : [any, any] + + "!==": [any, any]; +>"!==" : [any, any] + + "!": any; +>"!" : any + + "!!": any; +>"!!" : any + + or: Array>; +>or : RulesLogic[] + + and: Array>; +>and : RulesLogic[] + + ">": [RulesLogic, RulesLogic]; +>">" : [RulesLogic, RulesLogic] + + ">=": [RulesLogic, RulesLogic]; +>">=" : [RulesLogic, RulesLogic] + + "<": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<" : [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic] + + "<=": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<=" : [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic] + + max: Array>; +>max : RulesLogic[] + + min: Array>; +>min : RulesLogic[] + + "+": Array> | RulesLogic; +>"+" : RulesLogic[] | RulesLogic + + "-": Array> | RulesLogic; +>"-" : RulesLogic[] | RulesLogic + + "*": Array> | RulesLogic; +>"*" : RulesLogic[] | RulesLogic + + "/": Array> | RulesLogic; +>"/" : RulesLogic[] | RulesLogic + + "%": [RulesLogic, RulesLogic]; +>"%" : [RulesLogic, RulesLogic] + + map: [RulesLogic, RulesLogic]; +>map : [RulesLogic, RulesLogic] + + filter: [RulesLogic, RulesLogic]; +>filter : [RulesLogic, RulesLogic] + + reduce: [RulesLogic, RulesLogic, RulesLogic]; +>reduce : [RulesLogic, RulesLogic, RulesLogic] + + all: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>all : [RulesLogic[], RulesLogic] | [RulesLogic, RulesLogic] + + none: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>none : [RulesLogic[], RulesLogic] | [RulesLogic, RulesLogic] + + some: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>some : [RulesLogic[], RulesLogic] | [RulesLogic, RulesLogic] + + merge: Array> | RulesLogic>; +>merge : (RulesLogic[] | RulesLogic)[] + + inArray: [RulesLogic, Array>]; +>inArray : [RulesLogic, RulesLogic[]] + + inString: [RulesLogic, RulesLogic]; +>inString : [RulesLogic, RulesLogic] + + cat: Array>; +>cat : RulesLogic[] + + substr: [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>substr : [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic] + + log: RulesLogic; +>log : RulesLogic +} + +export type JsonLogicVar = Pick< +>JsonLogicVar : JsonLogicVar + + AllReservedOperationsInterface, + "var" +>; +export type JsonLogicMissing = Pick< +>JsonLogicMissing : JsonLogicMissing + + AllReservedOperationsInterface, + "missing" +>; +export type JsonLogicMissingSome = Pick< +>JsonLogicMissingSome : JsonLogicMissingSome + + AllReservedOperationsInterface, + "missing_some" +>; +export type JsonLogicIf = Pick; +>JsonLogicIf : JsonLogicIf + +export type JsonLogicEqual = Pick; +>JsonLogicEqual : JsonLogicEqual + +export type JsonLogicStrictEqual = Pick; +>JsonLogicStrictEqual : JsonLogicStrictEqual + +export type JsonLogicNotEqual = Pick; +>JsonLogicStrictNotEqual : JsonLogicStrictNotEqual + +export type JsonLogicNegation = Pick; +>JsonLogicNegation : JsonLogicNegation + +export type JsonLogicDoubleNegation = Pick; +>JsonLogicDoubleNegation : JsonLogicDoubleNegation + +export type JsonLogicOr = Pick< +>JsonLogicOr : JsonLogicOr + + AllReservedOperationsInterface, + "or" +>; +export type JsonLogicAnd = Pick< +>JsonLogicAnd : JsonLogicAnd + + AllReservedOperationsInterface, + "and" +>; +export type JsonLogicGreaterThan = Pick< +>JsonLogicGreaterThan : JsonLogicGreaterThan + + AllReservedOperationsInterface, + ">" +>; +export type JsonLogicGreaterThanOrEqual = Pick< +>JsonLogicGreaterThanOrEqual : JsonLogicGreaterThanOrEqual + + AllReservedOperationsInterface, + ">=" +>; +export type JsonLogicLessThan = Pick< +>JsonLogicLessThan : JsonLogicLessThan + + AllReservedOperationsInterface, + "<" +>; +export type JsonLogicLessThanOrEqual = Pick< +>JsonLogicLessThanOrEqual : JsonLogicLessThanOrEqual + + AllReservedOperationsInterface, + "<=" +>; +export type JsonLogicMax = Pick< +>JsonLogicMax : JsonLogicMax + + AllReservedOperationsInterface, + "max" +>; +export type JsonLogicMin = Pick< +>JsonLogicMin : JsonLogicMin + + AllReservedOperationsInterface, + "min" +>; +export type JsonLogicSum = Pick< +>JsonLogicSum : JsonLogicSum + + AllReservedOperationsInterface, + "+" +>; +export type JsonLogicDifference = Pick< +>JsonLogicDifference : JsonLogicDifference + + AllReservedOperationsInterface, + "-" +>; +export type JsonLogicProduct = Pick< +>JsonLogicProduct : JsonLogicProduct + + AllReservedOperationsInterface, + "*" +>; +export type JsonLogicQuotient = Pick< +>JsonLogicQuotient : JsonLogicQuotient + + AllReservedOperationsInterface, + "/" +>; +export type JsonLogicRemainder = Pick< +>JsonLogicRemainder : JsonLogicRemainder + + AllReservedOperationsInterface, + "%" +>; +export type JsonLogicMap = Pick< +>JsonLogicMap : JsonLogicMap + + AllReservedOperationsInterface, + "map" +>; +export type JsonLogicFilter = Pick< +>JsonLogicFilter : JsonLogicFilter + + AllReservedOperationsInterface, + "filter" +>; +export type JsonLogicReduce = Pick< +>JsonLogicReduce : JsonLogicReduce + + AllReservedOperationsInterface, + "reduce" +>; +export type JsonLogicAll = Pick< +>JsonLogicAll : JsonLogicAll + + AllReservedOperationsInterface, + "all" +>; +export type JsonLogicNone = Pick< +>JsonLogicNone : JsonLogicNone + + AllReservedOperationsInterface, + "none" +>; +export type JsonLogicSome = Pick< +>JsonLogicSome : JsonLogicSome + + AllReservedOperationsInterface, + "some" +>; +export type JsonLogicMerge = Pick< +>JsonLogicMerge : JsonLogicMerge + + AllReservedOperationsInterface, + "merge" +>; +export type JsonLogicInArray = RenameToIn< +>JsonLogicInArray : RenameToIn, "inArray">> + + Pick, "inArray"> +>; +export type JsonLogicInString = RenameToIn< +>JsonLogicInString : RenameToIn, "inString">> + + Pick, "inString"> +>; +export type JsonLogicCat = Pick< +>JsonLogicCat : JsonLogicCat + + AllReservedOperationsInterface, + "cat" +>; +export type JsonLogicSubstr = Pick< +>JsonLogicSubstr : JsonLogicSubstr + + AllReservedOperationsInterface, + "substr" +>; +export type JsonLogicLog = Pick< +>JsonLogicLog : JsonLogicLog + + AllReservedOperationsInterface, + "log" +>; + +export type RulesLogic = +>RulesLogic : RulesLogic + + | boolean + | string + | number + | null + // Accessing Data - https://jsonlogic.com/operations.html#accessing-data + | JsonLogicVar + | JsonLogicMissing + | JsonLogicMissingSome + // Logic and Boolean Operations - https://jsonlogic.com/operations.html#logic-and-boolean-operations + | JsonLogicIf + | JsonLogicEqual + | JsonLogicStrictEqual + | JsonLogicNotEqual + | JsonLogicStrictNotEqual + | JsonLogicNegation + | JsonLogicDoubleNegation + | JsonLogicOr + | JsonLogicAnd + // Numeric Operations - https://jsonlogic.com/operations.html#numeric-operations + | JsonLogicGreaterThan + | JsonLogicGreaterThanOrEqual + | JsonLogicLessThan + | JsonLogicLessThanOrEqual + | JsonLogicMax + | JsonLogicMin + | JsonLogicSum + | JsonLogicDifference + | JsonLogicProduct + | JsonLogicQuotient + | JsonLogicRemainder + // Array Operations - https://jsonlogic.com/operations.html#array-operations + | JsonLogicMap + | JsonLogicFilter + | JsonLogicReduce + | JsonLogicAll + | JsonLogicNone + | JsonLogicSome + | JsonLogicMerge + | JsonLogicInArray + // String Operations - https://jsonlogic.com/operations.html#string-operations + | JsonLogicInString + | JsonLogicCat + | JsonLogicSubstr + // Miscellaneous - https://jsonlogic.com/operations.html#miscellaneous + | JsonLogicLog + // Adding Operations (https://jsonlogic.com/add_operation.html) + | AddOps; + +export function add_operation(name: string, code: (...args: any[]) => any): void; +>add_operation : (name: string, code: (...args: any[]) => any) => void +>name : string +>code : (...args: any[]) => any +>args : any[] + +export function apply(logic: RulesLogic, data?: unknown): any; +>apply : (logic: RulesLogic, data?: unknown) => any +>logic : RulesLogic +>data : unknown + +export function rm_operation(name: string): void; +>rm_operation : (name: string) => void +>name : string + +// These functions are undocumented, but are exported by the real package +// so they're typed here for completeness. +export function is_logic(logic: any): logic is RulesLogic; +>is_logic : (logic: any) => logic is RulesLogic +>logic : any + +export function truthy(value: any): boolean; +>truthy : (value: any) => boolean +>value : any + +export function get_operator(logic: Record): string; +>get_operator : (logic: Record) => string +>logic : Record + +export function get_values(logic: Record): any; +>get_values : (logic: Record) => any +>logic : Record + +export function uses_data(logic: Record): any[]; +>uses_data : (logic: Record) => any[] +>logic : Record + +export function rule_like(rule: any, pattern: any): boolean; +>rule_like : (rule: any, pattern: any) => boolean +>rule : any +>pattern : any + +=== main.ts === +import * as jsonLogic from "./json-logic-js"; +>jsonLogic : typeof jsonLogic + +type StartsWithAndEndsWith = +>StartsWithAndEndsWith : StartsWithAndEndsWith + + | { startsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] } +>startsWith : [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] + + | { endsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] }; +>endsWith : [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] + +type JsonLogicWithAdditionalOperations = jsonLogic.RulesLogic; +>JsonLogicWithAdditionalOperations : JsonLogicWithAdditionalOperations +>jsonLogic : any + +const jsonExtendedLogic: JsonLogicWithAdditionalOperations = { +>jsonExtendedLogic : JsonLogicWithAdditionalOperations +>{ and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }],} : { and: ({ startsWith: [string, string]; } | { endsWith: [string, string]; })[]; } + + and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }], +>and : ({ startsWith: [string, string]; } | { endsWith: [string, string]; })[] +>[{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }] : ({ startsWith: [string, string]; } | { endsWith: [string, string]; })[] +>{ startsWith: ["Springfield", "Spring"] } : { startsWith: [string, string]; } +>startsWith : [string, string] +>["Springfield", "Spring"] : [string, string] +>"Springfield" : "Springfield" +>"Spring" : "Spring" +>{ endsWith: ["Springfield", "field"] } : { endsWith: [string, string]; } +>endsWith : [string, string] +>["Springfield", "field"] : [string, string] +>"Springfield" : "Springfield" +>"field" : "field" + +}; +jsonLogic.apply(jsonExtendedLogic); +>jsonLogic.apply(jsonExtendedLogic) : any +>jsonLogic.apply : (logic: jsonLogic.RulesLogic, data?: unknown) => any +>jsonLogic : typeof jsonLogic +>apply : (logic: jsonLogic.RulesLogic, data?: unknown) => any +>jsonExtendedLogic : jsonLogic.JsonLogicAnd + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.errors.txt new file mode 100644 index 0000000000000..85a24505357b2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.errors.txt @@ -0,0 +1,86 @@ +maFirst.ts(8,1): error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. +maFirst.ts(9,1): error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. + Types of property 'b' are incompatible. + Type 'MB>' is not assignable to type 'MB>'. + Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. +maFirst.ts(11,1): error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. + Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. + Types of property 'p' are incompatible. + Type 'string' is not assignable to type '"lit"'. +mbFirst.ts(9,1): error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. + Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. + Types of property 'p' are incompatible. + Type 'string' is not assignable to type '"lit"'. +mbFirst.ts(10,1): error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. +mbFirst.ts(11,1): error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. + Types of property 'b' are incompatible. + Type 'MB>' is not assignable to type 'MB>'. + Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. + + +==== maFirst.ts (3 errors) ==== + export {}; + + type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; + type MB = { f: (u: U) => void; a: MA> }; + + declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; + declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; + al = as; + ~~ +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + as = al; + ~~ +!!! error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'MB>' is not assignable to type 'MB>'. +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + bl = bs; + bs = bl; + ~~ +!!! error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. +!!! error TS2322: Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. +!!! error TS2322: Types of property 'p' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + +==== mbFirst.ts (3 errors) ==== + export {}; + + type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; + type MB = { f: (u: U) => void; a: MA> }; + + declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; + declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; + bl = bs; + bs = bl; + ~~ +!!! error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. +!!! error TS2322: Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. +!!! error TS2322: Types of property 'p' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + al = as; + ~~ +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + as = al; + ~~ +!!! error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'MB>' is not assignable to type 'MB>'. +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.symbols new file mode 100644 index 0000000000000..6859a8dde928b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.symbols @@ -0,0 +1,120 @@ +//// [tests/cases/compiler/varianceCycleStructuralFallback.ts] //// + +=== maFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) +>x : Symbol(x, Decl(maFirst.ts, 2, 14)) +>K : Symbol(K, Decl(maFirst.ts, 2, 21)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) +>K : Symbol(K, Decl(maFirst.ts, 2, 21)) +>b : Symbol(b, Decl(maFirst.ts, 2, 45)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) + +type MB = { f: (u: U) => void; a: MA> }; +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>U : Symbol(U, Decl(maFirst.ts, 3, 8)) +>f : Symbol(f, Decl(maFirst.ts, 3, 14)) +>u : Symbol(u, Decl(maFirst.ts, 3, 19)) +>U : Symbol(U, Decl(maFirst.ts, 3, 8)) +>a : Symbol(a, Decl(maFirst.ts, 3, 33)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>U : Symbol(U, Decl(maFirst.ts, 3, 8)) + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : Symbol(as, Decl(maFirst.ts, 5, 11)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>p : Symbol(p, Decl(maFirst.ts, 5, 20)) +>al : Symbol(al, Decl(maFirst.ts, 5, 34)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>p : Symbol(p, Decl(maFirst.ts, 5, 43)) + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : Symbol(bs, Decl(maFirst.ts, 6, 11)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>p : Symbol(p, Decl(maFirst.ts, 6, 20)) +>bl : Symbol(bl, Decl(maFirst.ts, 6, 34)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>p : Symbol(p, Decl(maFirst.ts, 6, 43)) + +al = as; +>al : Symbol(al, Decl(maFirst.ts, 5, 34)) +>as : Symbol(as, Decl(maFirst.ts, 5, 11)) + +as = al; +>as : Symbol(as, Decl(maFirst.ts, 5, 11)) +>al : Symbol(al, Decl(maFirst.ts, 5, 34)) + +bl = bs; +>bl : Symbol(bl, Decl(maFirst.ts, 6, 34)) +>bs : Symbol(bs, Decl(maFirst.ts, 6, 11)) + +bs = bl; +>bs : Symbol(bs, Decl(maFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(maFirst.ts, 6, 34)) + +=== mbFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) +>x : Symbol(x, Decl(mbFirst.ts, 2, 14)) +>K : Symbol(K, Decl(mbFirst.ts, 2, 21)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) +>K : Symbol(K, Decl(mbFirst.ts, 2, 21)) +>b : Symbol(b, Decl(mbFirst.ts, 2, 45)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) + +type MB = { f: (u: U) => void; a: MA> }; +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>U : Symbol(U, Decl(mbFirst.ts, 3, 8)) +>f : Symbol(f, Decl(mbFirst.ts, 3, 14)) +>u : Symbol(u, Decl(mbFirst.ts, 3, 19)) +>U : Symbol(U, Decl(mbFirst.ts, 3, 8)) +>a : Symbol(a, Decl(mbFirst.ts, 3, 33)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>U : Symbol(U, Decl(mbFirst.ts, 3, 8)) + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : Symbol(as, Decl(mbFirst.ts, 5, 11)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>p : Symbol(p, Decl(mbFirst.ts, 5, 20)) +>al : Symbol(al, Decl(mbFirst.ts, 5, 34)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>p : Symbol(p, Decl(mbFirst.ts, 5, 43)) + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : Symbol(bs, Decl(mbFirst.ts, 6, 11)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>p : Symbol(p, Decl(mbFirst.ts, 6, 20)) +>bl : Symbol(bl, Decl(mbFirst.ts, 6, 34)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>p : Symbol(p, Decl(mbFirst.ts, 6, 43)) + +bl = bs; +>bl : Symbol(bl, Decl(mbFirst.ts, 6, 34)) +>bs : Symbol(bs, Decl(mbFirst.ts, 6, 11)) + +bs = bl; +>bs : Symbol(bs, Decl(mbFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(mbFirst.ts, 6, 34)) + +al = as; +>al : Symbol(al, Decl(mbFirst.ts, 5, 34)) +>as : Symbol(as, Decl(mbFirst.ts, 5, 11)) + +as = al; +>as : Symbol(as, Decl(mbFirst.ts, 5, 11)) +>al : Symbol(al, Decl(mbFirst.ts, 5, 34)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.types b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.types new file mode 100644 index 0000000000000..e40fcb80e2fea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.types @@ -0,0 +1,94 @@ +//// [tests/cases/compiler/varianceCycleStructuralFallback.ts] //// + +=== maFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : MA +>x : { [K in keyof T]-?: T[K]; } +>b : MB> + +type MB = { f: (u: U) => void; a: MA> }; +>MB : MB +>f : (u: U) => void +>u : U +>a : MA> + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : MA<{ p: string; }> +>p : string +>al : MA<{ p: "lit"; }> +>p : "lit" + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : MB<{ p: string; }> +>p : string +>bl : MB<{ p: "lit"; }> +>p : "lit" + +al = as; +>al = as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> + +as = al; +>as = al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> + +bl = bs; +>bl = bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> + +bs = bl; +>bs = bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> + +=== mbFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : MA +>x : { [K in keyof T]-?: T[K]; } +>b : MB> + +type MB = { f: (u: U) => void; a: MA> }; +>MB : MB +>f : (u: U) => void +>u : U +>a : MA> + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : MA<{ p: string; }> +>p : string +>al : MA<{ p: "lit"; }> +>p : "lit" + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : MB<{ p: string; }> +>p : string +>bl : MB<{ p: "lit"; }> +>p : "lit" + +bl = bs; +>bl = bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> + +bs = bl; +>bs = bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> + +al = as; +>al = as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> + +as = al; +>as = al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> + diff --git a/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.symbols b/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.symbols new file mode 100644 index 0000000000000..a35b1188b91ef --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.symbols @@ -0,0 +1,126 @@ +//// [tests/cases/compiler/varianceDeclarationOrder.ts] //// + +=== refFirst.ts === +type M = { kind: "m" }; +>M : Symbol(M, Decl(refFirst.ts, 0, 0)) +>kind : Symbol(kind, Decl(refFirst.ts, 0, 10)) + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Symbol(Filtered, Decl(refFirst.ts, 0, 23)) +>T : Symbol(T, Decl(refFirst.ts, 1, 14)) +>K : Symbol(K, Decl(refFirst.ts, 1, 22)) +>T : Symbol(T, Decl(refFirst.ts, 1, 14)) +>T : Symbol(T, Decl(refFirst.ts, 1, 14)) +>K : Symbol(K, Decl(refFirst.ts, 1, 22)) +>M : Symbol(M, Decl(refFirst.ts, 0, 0)) +>K : Symbol(K, Decl(refFirst.ts, 1, 22)) +>T : Symbol(T, Decl(refFirst.ts, 1, 14)) +>K : Symbol(K, Decl(refFirst.ts, 1, 22)) + +interface Config { measure: keyof T } +>Config : Symbol(Config, Decl(refFirst.ts, 1, 74)) +>T : Symbol(T, Decl(refFirst.ts, 2, 17)) +>measure : Symbol(Config.measure, Decl(refFirst.ts, 2, 21)) +>T : Symbol(T, Decl(refFirst.ts, 2, 17)) + +interface Ref { dataset: DS, N> } +>Ref : Symbol(Ref, Decl(refFirst.ts, 2, 40)) +>N : Symbol(N, Decl(refFirst.ts, 3, 14)) +>dataset : Symbol(Ref.dataset, Decl(refFirst.ts, 3, 18)) +>DS : Symbol(DS, Decl(refFirst.ts, 3, 54)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(refFirst.ts, 0, 0)) +>N : Symbol(N, Decl(refFirst.ts, 3, 14)) + +interface DS { +>DS : Symbol(DS, Decl(refFirst.ts, 3, 54)) +>T : Symbol(T, Decl(refFirst.ts, 4, 13)) +>N : Symbol(N, Decl(refFirst.ts, 4, 15)) + + a(config: Config>): void; +>a : Symbol(DS.a, Decl(refFirst.ts, 4, 20)) +>config : Symbol(config, Decl(refFirst.ts, 5, 6)) +>Config : Symbol(Config, Decl(refFirst.ts, 1, 74)) +>Filtered : Symbol(Filtered, Decl(refFirst.ts, 0, 23)) +>T : Symbol(T, Decl(refFirst.ts, 4, 13)) + + b: Ref; +>b : Symbol(DS.b, Decl(refFirst.ts, 5, 41)) +>Ref : Symbol(Ref, Decl(refFirst.ts, 2, 40)) +>N : Symbol(N, Decl(refFirst.ts, 4, 15)) +} +declare const x: DS<{ total: M }, string>; +>x : Symbol(x, Decl(refFirst.ts, 8, 13)) +>DS : Symbol(DS, Decl(refFirst.ts, 3, 54)) +>total : Symbol(total, Decl(refFirst.ts, 8, 21)) +>M : Symbol(M, Decl(refFirst.ts, 0, 0)) + +export const y: DS, string> = x; +>y : Symbol(y, Decl(refFirst.ts, 9, 12)) +>DS : Symbol(DS, Decl(refFirst.ts, 3, 54)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(refFirst.ts, 0, 0)) +>x : Symbol(x, Decl(refFirst.ts, 8, 13)) + +=== dsFirst.ts === +type M = { kind: "m" }; +>M : Symbol(M, Decl(dsFirst.ts, 0, 0)) +>kind : Symbol(kind, Decl(dsFirst.ts, 0, 10)) + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Symbol(Filtered, Decl(dsFirst.ts, 0, 23)) +>T : Symbol(T, Decl(dsFirst.ts, 1, 14)) +>K : Symbol(K, Decl(dsFirst.ts, 1, 22)) +>T : Symbol(T, Decl(dsFirst.ts, 1, 14)) +>T : Symbol(T, Decl(dsFirst.ts, 1, 14)) +>K : Symbol(K, Decl(dsFirst.ts, 1, 22)) +>M : Symbol(M, Decl(dsFirst.ts, 0, 0)) +>K : Symbol(K, Decl(dsFirst.ts, 1, 22)) +>T : Symbol(T, Decl(dsFirst.ts, 1, 14)) +>K : Symbol(K, Decl(dsFirst.ts, 1, 22)) + +interface Config { measure: keyof T } +>Config : Symbol(Config, Decl(dsFirst.ts, 1, 74)) +>T : Symbol(T, Decl(dsFirst.ts, 2, 17)) +>measure : Symbol(Config.measure, Decl(dsFirst.ts, 2, 21)) +>T : Symbol(T, Decl(dsFirst.ts, 2, 17)) + +interface DS { +>DS : Symbol(DS, Decl(dsFirst.ts, 2, 40)) +>T : Symbol(T, Decl(dsFirst.ts, 3, 13)) +>N : Symbol(N, Decl(dsFirst.ts, 3, 15)) + + a(config: Config>): void; +>a : Symbol(DS.a, Decl(dsFirst.ts, 3, 20)) +>config : Symbol(config, Decl(dsFirst.ts, 4, 6)) +>Config : Symbol(Config, Decl(dsFirst.ts, 1, 74)) +>Filtered : Symbol(Filtered, Decl(dsFirst.ts, 0, 23)) +>T : Symbol(T, Decl(dsFirst.ts, 3, 13)) + + b: Ref; +>b : Symbol(DS.b, Decl(dsFirst.ts, 4, 41)) +>Ref : Symbol(Ref, Decl(dsFirst.ts, 6, 1)) +>N : Symbol(N, Decl(dsFirst.ts, 3, 15)) +} +interface Ref { dataset: DS, N> } +>Ref : Symbol(Ref, Decl(dsFirst.ts, 6, 1)) +>N : Symbol(N, Decl(dsFirst.ts, 7, 14)) +>dataset : Symbol(Ref.dataset, Decl(dsFirst.ts, 7, 18)) +>DS : Symbol(DS, Decl(dsFirst.ts, 2, 40)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(dsFirst.ts, 0, 0)) +>N : Symbol(N, Decl(dsFirst.ts, 7, 14)) + +declare const x: DS<{ total: M }, string>; +>x : Symbol(x, Decl(dsFirst.ts, 8, 13)) +>DS : Symbol(DS, Decl(dsFirst.ts, 2, 40)) +>total : Symbol(total, Decl(dsFirst.ts, 8, 21)) +>M : Symbol(M, Decl(dsFirst.ts, 0, 0)) + +export const y: DS, string> = x; +>y : Symbol(y, Decl(dsFirst.ts, 9, 12)) +>DS : Symbol(DS, Decl(dsFirst.ts, 2, 40)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(dsFirst.ts, 0, 0)) +>x : Symbol(x, Decl(dsFirst.ts, 8, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.types b/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.types new file mode 100644 index 0000000000000..c084cea2f9d50 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.types @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/varianceDeclarationOrder.ts] //// + +=== refFirst.ts === +type M = { kind: "m" }; +>M : M +>kind : "m" + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Filtered + +interface Config { measure: keyof T } +>measure : keyof T + +interface Ref { dataset: DS, N> } +>dataset : DS, N> + +interface DS { + a(config: Config>): void; +>a : (config: Config>) => void +>config : Config> + + b: Ref; +>b : Ref +} +declare const x: DS<{ total: M }, string>; +>x : DS<{ total: M; }, string> +>total : M + +export const y: DS, string> = x; +>y : DS, string> +>x : DS<{ total: M; }, string> + +=== dsFirst.ts === +type M = { kind: "m" }; +>M : M +>kind : "m" + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Filtered + +interface Config { measure: keyof T } +>measure : keyof T + +interface DS { + a(config: Config>): void; +>a : (config: Config>) => void +>config : Config> + + b: Ref; +>b : Ref +} +interface Ref { dataset: DS, N> } +>dataset : DS, N> + +declare const x: DS<{ total: M }, string>; +>x : DS<{ total: M; }, string> +>total : M + +export const y: DS, string> = x; +>y : DS, string> +>x : DS<{ total: M; }, string> + diff --git a/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.errors.txt new file mode 100644 index 0000000000000..d3d975854426a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.errors.txt @@ -0,0 +1,63 @@ +varianceMeasuredWithinCircularity.ts(24,5): error TS2322: Type 'Selection' is not assignable to type 'Selection'. + Types of property 'join' are incompatible. + Type '(enter: string | ((elem: Selection) => Selection | TransitionLike)) => Selection' is not assignable to type '(enter: string | ((elem: Selection) => Selection | TransitionLike)) => Selection'. + Types of parameters 'enter' and 'enter' are incompatible. + Type 'string | ((elem: Selection) => Selection | TransitionLike)' is not assignable to type 'string | ((elem: Selection) => Selection | TransitionLike)'. + Type '(elem: Selection) => Selection | TransitionLike' is not assignable to type 'string | ((elem: Selection) => Selection | TransitionLike)'. + Type '(elem: Selection) => Selection | TransitionLike' is not assignable to type '(elem: Selection) => Selection | TransitionLike'. + Type 'Selection | TransitionLike' is not assignable to type 'Selection | TransitionLike'. + Type 'Selection' is not assignable to type 'Selection | TransitionLike'. + Type 'Selection' is not assignable to type 'Selection'. + Types of property 'data' are incompatible. + Type '(key: (parent: Base) => string) => Selection' is not assignable to type '(key: (parent: Derived) => string) => Selection'. + Types of parameters 'key' and 'key' are incompatible. + Types of parameters 'parent' and 'parent' are incompatible. + Property 'derived' is missing in type 'Base' but required in type 'Derived'. + + +==== varianceMeasuredWithinCircularity.ts (1 errors) ==== + // The variances of Selection and TransitionLike depend on each other. + // The callback of `data` requires Selection to be covariant in P, while + // `join` passes Selection to a callback, which then requires it to + // be contravariant in P, so Selection is invariant in P. TransitionLike + // reaches P of a Selection through `selection().children()`, so it is + // invariant in G. Both must hold whichever variance is measured first. + + export {}; + + interface Base { base: string } + interface Derived extends Base { derived: string } + + interface Selection { + data(key: (parent: P) => string): Selection; + join(enter: string | ((elem: Selection) => Selection | TransitionLike)): Selection; + children(): Selection; + } + + interface TransitionLike { + selection(): Selection; + } + + declare let s1: Selection; + let s2: Selection = s1; + ~~ +!!! error TS2322: Type 'Selection' is not assignable to type 'Selection'. +!!! error TS2322: Types of property 'join' are incompatible. +!!! error TS2322: Type '(enter: string | ((elem: Selection) => Selection | TransitionLike)) => Selection' is not assignable to type '(enter: string | ((elem: Selection) => Selection | TransitionLike)) => Selection'. +!!! error TS2322: Types of parameters 'enter' and 'enter' are incompatible. +!!! error TS2322: Type 'string | ((elem: Selection) => Selection | TransitionLike)' is not assignable to type 'string | ((elem: Selection) => Selection | TransitionLike)'. +!!! error TS2322: Type '(elem: Selection) => Selection | TransitionLike' is not assignable to type 'string | ((elem: Selection) => Selection | TransitionLike)'. +!!! error TS2322: Type '(elem: Selection) => Selection | TransitionLike' is not assignable to type '(elem: Selection) => Selection | TransitionLike'. +!!! error TS2322: Type 'Selection | TransitionLike' is not assignable to type 'Selection | TransitionLike'. +!!! error TS2322: Type 'Selection' is not assignable to type 'Selection | TransitionLike'. +!!! error TS2322: Type 'Selection' is not assignable to type 'Selection'. +!!! error TS2322: Types of property 'data' are incompatible. +!!! error TS2322: Type '(key: (parent: Base) => string) => Selection' is not assignable to type '(key: (parent: Derived) => string) => Selection'. +!!! error TS2322: Types of parameters 'key' and 'key' are incompatible. +!!! error TS2322: Types of parameters 'parent' and 'parent' are incompatible. +!!! error TS2322: Property 'derived' is missing in type 'Base' but required in type 'Derived'. +!!! related TS2728 varianceMeasuredWithinCircularity.ts:11:34: 'derived' is declared here. + + declare let t1: TransitionLike; + let t2: TransitionLike = t1; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.symbols b/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.symbols new file mode 100644 index 0000000000000..23cef834c47e8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.symbols @@ -0,0 +1,89 @@ +//// [tests/cases/compiler/varianceMeasuredWithinCircularity.ts] //// + +=== varianceMeasuredWithinCircularity.ts === +// The variances of Selection and TransitionLike depend on each other. +// The callback of `data` requires Selection to be covariant in P, while +// `join` passes Selection to a callback, which then requires it to +// be contravariant in P, so Selection is invariant in P. TransitionLike +// reaches P of a Selection through `selection().children()`, so it is +// invariant in G. Both must hold whichever variance is measured first. + +export {}; + +interface Base { base: string } +>Base : Symbol(Base, Decl(varianceMeasuredWithinCircularity.ts, 7, 10)) +>base : Symbol(Base.base, Decl(varianceMeasuredWithinCircularity.ts, 9, 16)) + +interface Derived extends Base { derived: string } +>Derived : Symbol(Derived, Decl(varianceMeasuredWithinCircularity.ts, 9, 31)) +>Base : Symbol(Base, Decl(varianceMeasuredWithinCircularity.ts, 7, 10)) +>derived : Symbol(Derived.derived, Decl(varianceMeasuredWithinCircularity.ts, 10, 32)) + +interface Selection { +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 12, 20)) +>P : Symbol(P, Decl(varianceMeasuredWithinCircularity.ts, 12, 22)) + + data(key: (parent: P) => string): Selection; +>data : Symbol(Selection.data, Decl(varianceMeasuredWithinCircularity.ts, 12, 27)) +>key : Symbol(key, Decl(varianceMeasuredWithinCircularity.ts, 13, 9)) +>parent : Symbol(parent, Decl(varianceMeasuredWithinCircularity.ts, 13, 15)) +>P : Symbol(P, Decl(varianceMeasuredWithinCircularity.ts, 12, 22)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 12, 20)) +>P : Symbol(P, Decl(varianceMeasuredWithinCircularity.ts, 12, 22)) + + join(enter: string | ((elem: Selection) => Selection | TransitionLike)): Selection; +>join : Symbol(Selection.join, Decl(varianceMeasuredWithinCircularity.ts, 13, 54)) +>enter : Symbol(enter, Decl(varianceMeasuredWithinCircularity.ts, 14, 9)) +>elem : Symbol(elem, Decl(varianceMeasuredWithinCircularity.ts, 14, 27)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 12, 20)) +>P : Symbol(P, Decl(varianceMeasuredWithinCircularity.ts, 12, 22)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 12, 20)) +>P : Symbol(P, Decl(varianceMeasuredWithinCircularity.ts, 12, 22)) +>TransitionLike : Symbol(TransitionLike, Decl(varianceMeasuredWithinCircularity.ts, 16, 1)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 12, 20)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 12, 20)) +>P : Symbol(P, Decl(varianceMeasuredWithinCircularity.ts, 12, 22)) + + children(): Selection; +>children : Symbol(Selection.children, Decl(varianceMeasuredWithinCircularity.ts, 14, 108)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 12, 20)) +} + +interface TransitionLike { +>TransitionLike : Symbol(TransitionLike, Decl(varianceMeasuredWithinCircularity.ts, 16, 1)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 18, 25)) + + selection(): Selection; +>selection : Symbol(TransitionLike.selection, Decl(varianceMeasuredWithinCircularity.ts, 18, 29)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>G : Symbol(G, Decl(varianceMeasuredWithinCircularity.ts, 18, 25)) +} + +declare let s1: Selection; +>s1 : Symbol(s1, Decl(varianceMeasuredWithinCircularity.ts, 22, 11)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>Derived : Symbol(Derived, Decl(varianceMeasuredWithinCircularity.ts, 9, 31)) + +let s2: Selection = s1; +>s2 : Symbol(s2, Decl(varianceMeasuredWithinCircularity.ts, 23, 3)) +>Selection : Symbol(Selection, Decl(varianceMeasuredWithinCircularity.ts, 10, 50)) +>Base : Symbol(Base, Decl(varianceMeasuredWithinCircularity.ts, 7, 10)) +>s1 : Symbol(s1, Decl(varianceMeasuredWithinCircularity.ts, 22, 11)) + +declare let t1: TransitionLike; +>t1 : Symbol(t1, Decl(varianceMeasuredWithinCircularity.ts, 25, 11)) +>TransitionLike : Symbol(TransitionLike, Decl(varianceMeasuredWithinCircularity.ts, 16, 1)) +>Derived : Symbol(Derived, Decl(varianceMeasuredWithinCircularity.ts, 9, 31)) + +let t2: TransitionLike = t1; +>t2 : Symbol(t2, Decl(varianceMeasuredWithinCircularity.ts, 26, 3)) +>TransitionLike : Symbol(TransitionLike, Decl(varianceMeasuredWithinCircularity.ts, 16, 1)) +>Base : Symbol(Base, Decl(varianceMeasuredWithinCircularity.ts, 7, 10)) +>t1 : Symbol(t1, Decl(varianceMeasuredWithinCircularity.ts, 25, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.types b/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.types new file mode 100644 index 0000000000000..e6075d898565c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.types @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/varianceMeasuredWithinCircularity.ts] //// + +=== varianceMeasuredWithinCircularity.ts === +// The variances of Selection and TransitionLike depend on each other. +// The callback of `data` requires Selection to be covariant in P, while +// `join` passes Selection to a callback, which then requires it to +// be contravariant in P, so Selection is invariant in P. TransitionLike +// reaches P of a Selection through `selection().children()`, so it is +// invariant in G. Both must hold whichever variance is measured first. + +export {}; + +interface Base { base: string } +>base : string + +interface Derived extends Base { derived: string } +>derived : string + +interface Selection { + data(key: (parent: P) => string): Selection; +>data : (key: (parent: P) => string) => Selection +>key : (parent: P) => string +>parent : P + + join(enter: string | ((elem: Selection) => Selection | TransitionLike)): Selection; +>join : (enter: string | ((elem: Selection) => Selection | TransitionLike)) => Selection +>enter : string | ((elem: Selection) => Selection | TransitionLike) +>elem : Selection + + children(): Selection; +>children : () => Selection +} + +interface TransitionLike { + selection(): Selection; +>selection : () => Selection +} + +declare let s1: Selection; +>s1 : Selection + +let s2: Selection = s1; +>s2 : Selection +>s1 : Selection + +declare let t1: TransitionLike; +>t1 : TransitionLike + +let t2: TransitionLike = t1; +>t2 : TransitionLike +>t1 : TransitionLike + diff --git a/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).symbols new file mode 100644 index 0000000000000..c191ffdb6c463 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +declare let b2: B<"s">; +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +b1 = b2; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) + +interface A { m(x: B): Check>; } +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>m : Symbol(A.m, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 16)) +>x : Symbol(x, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 19)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +interface B { a: A; } +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) +>a : Symbol(B.a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 16)) +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>a : Symbol(a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 27)) + +const v: Check> = "yes"; +>v : Symbol(v, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 16, 5)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).types new file mode 100644 index 0000000000000..0e07b1ec22a18 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : B + +declare let b2: B<"s">; +>b2 : B<"s"> + +b1 = b2; +>b1 = b2 : B<"s"> +>b1 : B +>b2 : B<"s"> + +interface A { m(x: B): Check>; } +>m : (x: B) => Check> +>x : B + +interface B { a: A; } +>a : A + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Check +>a : unknown + +const v: Check> = "yes"; +>v : "yes" +>"yes" : "yes" + diff --git a/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c191ffdb6c463 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +declare let b2: B<"s">; +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +b1 = b2; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) + +interface A { m(x: B): Check>; } +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>m : Symbol(A.m, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 16)) +>x : Symbol(x, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 19)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +interface B { a: A; } +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) +>a : Symbol(B.a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 16)) +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>a : Symbol(a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 27)) + +const v: Check> = "yes"; +>v : Symbol(v, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 16, 5)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).types new file mode 100644 index 0000000000000..0e07b1ec22a18 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : B + +declare let b2: B<"s">; +>b2 : B<"s"> + +b1 = b2; +>b1 = b2 : B<"s"> +>b1 : B +>b2 : B<"s"> + +interface A { m(x: B): Check>; } +>m : (x: B) => Check> +>x : B + +interface B { a: A; } +>a : A + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Check +>a : unknown + +const v: Check> = "yes"; +>v : "yes" +>"yes" : "yes" + diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).errors.txt new file mode 100644 index 0000000000000..5529a3e5e68c6 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).errors.txt @@ -0,0 +1,149 @@ +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,9): error TS2322: Type '{ c: number; f: any; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,14): error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,45): error TS2448: Block-scoped variable 'f' used before its declaration. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,9): error TS2322: Type '{ c: number; f: () => any; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,9): error TS2322: Type '{ c: number; f: number; g: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,17): error TS2339: Property 'g' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,9): error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,14): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,17): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,17): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,9): error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,17): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(30,14): error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +dependentDestructuredVariablesReferenceInDeclaration1.ts(30,71): error TS2448: Block-scoped variable 'f' used before its declaration. +dependentDestructuredVariablesReferenceInDeclaration1.ts(58,14): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(58,17): error TS2451: Cannot redeclare block-scoped variable 'f'. + + +==== dependentDestructuredVariablesReferenceInDeclaration1.ts (26 errors) ==== + // https://github.com/microsoft/TypeScript/issues/62993 + + { + const { c, f }: string | number = { c: 0, f }; + ~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: any; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. +!!! related TS2728 dependentDestructuredVariablesReferenceInDeclaration1.ts:4:14: 'f' is declared here. + f; + } + + { + const { c, f }: string | number = { c: 0, f: () => f }; + ~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: () => any; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + f; + } + + { + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; g: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'g' does not exist on type 'string | number'. + f; + g; + } + + { + const { c, f, f }: string | number = { c: 0, f: 0 }; + ~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + f; + } + + { + const { c, f, f: g }: string | number = { c: 0, f: 0 }; + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + g; + } + + { + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; + ~ +!!! error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. +!!! related TS2728 dependentDestructuredVariablesReferenceInDeclaration1.ts:30:14: 'f' is declared here. + f; + } + + { + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { + c: 0, + f: () => f, + }; + f; + } + + { + const { + c, + f, + g = f, + }: + | { c: 0; f: bigint; g?: bigint | number } + | { c: 1; f: number; g: string } = { + c: 0, + f: 10n, + }; + f; + g; + } + + { + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + f; + } + + { + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; + g; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).symbols b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).symbols new file mode 100644 index 0000000000000..dd70a6b10cfe7 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).symbols @@ -0,0 +1,175 @@ +//// [tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts] //// + +=== dependentDestructuredVariablesReferenceInDeclaration1.ts === +// https://github.com/microsoft/TypeScript/issues/62993 + +{ + const { c, f }: string | number = { c: 0, f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 37)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 43)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 12)) +} + +{ + const { c, f }: string | number = { c: 0, f: () => f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 37)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 43)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) +} + +{ + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 15)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 44)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 50)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 56)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 15)) +} + +{ + const { c, f, f }: string | number = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 40)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 46)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 12)) +} + +{ + const { c, f, f: g }: string | number = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 12)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 43)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 49)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 15)) +} + +{ + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 19)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 25)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 41)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 47)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 63)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 69)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 12)) +} + +{ + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 19)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 25)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 48)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 54)) + + c: 0, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 70)) + + f: () => f, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 35, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) + + }; + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) +} + +{ + const { + c, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 42, 9)) + + f, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + g = f, +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 44, 6)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + }: + | { c: 0; f: bigint; g?: bigint | number } +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 7)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 13)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 24)) + + | { c: 1; f: number; g: string } = { +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 7)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 13)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 24)) + + c: 0, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 40)) + + f: 10n, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 49, 9)) + + }; + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 44, 6)) +} + +{ + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 22)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 28)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 44)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 50)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 66)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 72)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 12)) +} + +{ + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 31), Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 53)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 25)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 31)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 47)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 53)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 69)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 75)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 15)) +} + diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).types b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).types new file mode 100644 index 0000000000000..1e1c61a26976d --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).types @@ -0,0 +1,205 @@ +//// [tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts] //// + +=== dependentDestructuredVariablesReferenceInDeclaration1.ts === +// https://github.com/microsoft/TypeScript/issues/62993 + +{ + const { c, f }: string | number = { c: 0, f }; +>c : any +>f : any +>{ c: 0, f } : { c: number; f: any; } +>c : number +>0 : 0 +>f : any + + f; +>f : any +} + +{ + const { c, f }: string | number = { c: 0, f: () => f }; +>c : any +>f : any +>{ c: 0, f: () => f } : { c: number; f: () => any; } +>c : number +>0 : 0 +>f : () => any +>() => f : () => any +>f : any + + f; +>f : any +} + +{ + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; +>c : any +>f : any +>g : any +>f : any +>{ c: 0, f: 0, g: 0 } : { c: number; f: number; g: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 +>g : number +>0 : 0 + + f; +>f : any + + g; +>g : any +} + +{ + const { c, f, f }: string | number = { c: 0, f: 0 }; +>c : any +>f : any +>f : any +>{ c: 0, f: 0 } : { c: number; f: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 + + f; +>f : any +} + +{ + const { c, f, f: g }: string | number = { c: 0, f: 0 }; +>c : any +>f : any +>f : any +>g : any +>{ c: 0, f: 0 } : { c: number; f: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 + + g; +>g : any +} + +{ + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; +>c : 0 | 1 +>f : any +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f } : { c: 0; f: any; } +>c : 0 +>0 : 0 +>f : any + + f; +>f : string | number +} + +{ + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { +>c : 0 | 1 +>f : string | (() => unknown) +>c : 0 +>f : () => unknown +>c : 1 +>f : string +>{ c: 0, f: () => f, } : { c: 0; f: () => string | (() => unknown); } + + c: 0, +>c : 0 +>0 : 0 + + f: () => f, +>f : () => string | (() => unknown) +>() => f : () => string | (() => unknown) +>f : string | (() => unknown) + + }; + f; +>f : () => unknown +} + +{ + const { + c, +>c : 0 | 1 + + f, +>f : number | bigint + + g = f, +>g : string | number | bigint +>f : number | bigint + + }: + | { c: 0; f: bigint; g?: bigint | number } +>c : 0 +>f : bigint +>g : number | bigint | undefined + + | { c: 1; f: number; g: string } = { +>c : 1 +>f : number +>g : string +>{ c: 0, f: 10n, } : { c: 0; f: bigint; } + + c: 0, +>c : 0 +>0 : 0 + + f: 10n, +>f : bigint +>10n : 10n + + }; + f; +>f : bigint + + g; +>g : string | number | bigint +} + +{ + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : 0 | 1 +>f : string | number +>f : string | number +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f: 0 } : { c: 0; f: number; } +>c : 0 +>0 : 0 +>f : number +>0 : 0 + + f; +>f : number +} + +{ + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : 0 | 1 +>f : string | number +>f : any +>g : string | number +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f: 0 } : { c: 0; f: number; } +>c : 0 +>0 : 0 +>f : number +>0 : 0 + + g; +>g : number +} + diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..5529a3e5e68c6 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt @@ -0,0 +1,149 @@ +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,9): error TS2322: Type '{ c: number; f: any; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,14): error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,45): error TS2448: Block-scoped variable 'f' used before its declaration. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,9): error TS2322: Type '{ c: number; f: () => any; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,9): error TS2322: Type '{ c: number; f: number; g: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,17): error TS2339: Property 'g' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,9): error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,14): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,17): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,17): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,9): error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,17): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(30,14): error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +dependentDestructuredVariablesReferenceInDeclaration1.ts(30,71): error TS2448: Block-scoped variable 'f' used before its declaration. +dependentDestructuredVariablesReferenceInDeclaration1.ts(58,14): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(58,17): error TS2451: Cannot redeclare block-scoped variable 'f'. + + +==== dependentDestructuredVariablesReferenceInDeclaration1.ts (26 errors) ==== + // https://github.com/microsoft/TypeScript/issues/62993 + + { + const { c, f }: string | number = { c: 0, f }; + ~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: any; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. +!!! related TS2728 dependentDestructuredVariablesReferenceInDeclaration1.ts:4:14: 'f' is declared here. + f; + } + + { + const { c, f }: string | number = { c: 0, f: () => f }; + ~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: () => any; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + f; + } + + { + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; g: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'g' does not exist on type 'string | number'. + f; + g; + } + + { + const { c, f, f }: string | number = { c: 0, f: 0 }; + ~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + f; + } + + { + const { c, f, f: g }: string | number = { c: 0, f: 0 }; + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + g; + } + + { + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; + ~ +!!! error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. +!!! related TS2728 dependentDestructuredVariablesReferenceInDeclaration1.ts:30:14: 'f' is declared here. + f; + } + + { + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { + c: 0, + f: () => f, + }; + f; + } + + { + const { + c, + f, + g = f, + }: + | { c: 0; f: bigint; g?: bigint | number } + | { c: 1; f: number; g: string } = { + c: 0, + f: 10n, + }; + f; + g; + } + + { + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + f; + } + + { + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; + g; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..dd70a6b10cfe7 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).symbols @@ -0,0 +1,175 @@ +//// [tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts] //// + +=== dependentDestructuredVariablesReferenceInDeclaration1.ts === +// https://github.com/microsoft/TypeScript/issues/62993 + +{ + const { c, f }: string | number = { c: 0, f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 37)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 43)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 12)) +} + +{ + const { c, f }: string | number = { c: 0, f: () => f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 37)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 43)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) +} + +{ + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 15)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 44)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 50)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 56)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 15)) +} + +{ + const { c, f, f }: string | number = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 40)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 46)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 12)) +} + +{ + const { c, f, f: g }: string | number = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 12)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 43)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 49)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 15)) +} + +{ + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 19)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 25)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 41)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 47)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 63)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 69)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 12)) +} + +{ + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 19)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 25)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 48)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 54)) + + c: 0, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 70)) + + f: () => f, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 35, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) + + }; + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) +} + +{ + const { + c, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 42, 9)) + + f, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + g = f, +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 44, 6)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + }: + | { c: 0; f: bigint; g?: bigint | number } +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 7)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 13)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 24)) + + | { c: 1; f: number; g: string } = { +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 7)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 13)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 24)) + + c: 0, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 40)) + + f: 10n, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 49, 9)) + + }; + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 44, 6)) +} + +{ + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 22)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 28)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 44)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 50)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 66)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 72)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 12)) +} + +{ + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 31), Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 53)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 25)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 31)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 47)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 53)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 69)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 75)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 15)) +} + diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types new file mode 100644 index 0000000000000..1e1c61a26976d --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types @@ -0,0 +1,205 @@ +//// [tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts] //// + +=== dependentDestructuredVariablesReferenceInDeclaration1.ts === +// https://github.com/microsoft/TypeScript/issues/62993 + +{ + const { c, f }: string | number = { c: 0, f }; +>c : any +>f : any +>{ c: 0, f } : { c: number; f: any; } +>c : number +>0 : 0 +>f : any + + f; +>f : any +} + +{ + const { c, f }: string | number = { c: 0, f: () => f }; +>c : any +>f : any +>{ c: 0, f: () => f } : { c: number; f: () => any; } +>c : number +>0 : 0 +>f : () => any +>() => f : () => any +>f : any + + f; +>f : any +} + +{ + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; +>c : any +>f : any +>g : any +>f : any +>{ c: 0, f: 0, g: 0 } : { c: number; f: number; g: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 +>g : number +>0 : 0 + + f; +>f : any + + g; +>g : any +} + +{ + const { c, f, f }: string | number = { c: 0, f: 0 }; +>c : any +>f : any +>f : any +>{ c: 0, f: 0 } : { c: number; f: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 + + f; +>f : any +} + +{ + const { c, f, f: g }: string | number = { c: 0, f: 0 }; +>c : any +>f : any +>f : any +>g : any +>{ c: 0, f: 0 } : { c: number; f: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 + + g; +>g : any +} + +{ + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; +>c : 0 | 1 +>f : any +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f } : { c: 0; f: any; } +>c : 0 +>0 : 0 +>f : any + + f; +>f : string | number +} + +{ + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { +>c : 0 | 1 +>f : string | (() => unknown) +>c : 0 +>f : () => unknown +>c : 1 +>f : string +>{ c: 0, f: () => f, } : { c: 0; f: () => string | (() => unknown); } + + c: 0, +>c : 0 +>0 : 0 + + f: () => f, +>f : () => string | (() => unknown) +>() => f : () => string | (() => unknown) +>f : string | (() => unknown) + + }; + f; +>f : () => unknown +} + +{ + const { + c, +>c : 0 | 1 + + f, +>f : number | bigint + + g = f, +>g : string | number | bigint +>f : number | bigint + + }: + | { c: 0; f: bigint; g?: bigint | number } +>c : 0 +>f : bigint +>g : number | bigint | undefined + + | { c: 1; f: number; g: string } = { +>c : 1 +>f : number +>g : string +>{ c: 0, f: 10n, } : { c: 0; f: bigint; } + + c: 0, +>c : 0 +>0 : 0 + + f: 10n, +>f : bigint +>10n : 10n + + }; + f; +>f : bigint + + g; +>g : string | number | bigint +} + +{ + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : 0 | 1 +>f : string | number +>f : string | number +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f: 0 } : { c: 0; f: number; } +>c : 0 +>0 : 0 +>f : number +>0 : 0 + + f; +>f : number +} + +{ + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : 0 | 1 +>f : string | number +>f : any +>g : string | number +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f: 0 } : { c: 0; f: number; } +>c : 0 +>0 : 0 +>f : number +>0 : 0 + + g; +>g : number +} + diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).js b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).js new file mode 100644 index 0000000000000..c76356d188d89 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).js @@ -0,0 +1,126 @@ +//// [tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts] //// + +//// [destructuringWithLiteralInitializers.ts] +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +f1({ x: 1, y: 1 }); + +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +f2({ x: 1 }); +f2({ x: 1, y: 1 }); + +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +f3({}); +f3({ x: 1 }); +f3({ y: 1 }); +f3({ x: 1, y: 1 }); + +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +f4(); +f4({ x: 1, y: 1 }); + +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +f5(); +f5({ x: 1 }); +f5({ x: 1, y: 1 }); + +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +f6(); +f6({}); +f6({ x: 1 }); +f6({ y: 1 }); +f6({ x: 1, y: 1 }); + +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +f7(); +f7({ a: {} }); +f7({ a: { x: 1 } }); +f7({ a: { y: 1 } }); +f7({ a: { x: 1, y: 1 } }); + +// (arg: [any, any]) => void +function g1([x, y]) { } +g1([1, 1]); + +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +g2([1, 1]); + +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +g3(); +g3([1, 1]); + +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +g4(); +g4([1, 1]); + +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +g5(); +g5([1, 1]); + + +//// [destructuringWithLiteralInitializers.js] +"use strict"; +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +f1({ x: 1, y: 1 }); +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +f2({ x: 1 }); +f2({ x: 1, y: 1 }); +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +f3({}); +f3({ x: 1 }); +f3({ y: 1 }); +f3({ x: 1, y: 1 }); +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +f4(); +f4({ x: 1, y: 1 }); +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +f5(); +f5({ x: 1 }); +f5({ x: 1, y: 1 }); +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +f6(); +f6({}); +f6({ x: 1 }); +f6({ y: 1 }); +f6({ x: 1, y: 1 }); +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +f7(); +f7({ a: {} }); +f7({ a: { x: 1 } }); +f7({ a: { y: 1 } }); +f7({ a: { x: 1, y: 1 } }); +// (arg: [any, any]) => void +function g1([x, y]) { } +g1([1, 1]); +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +g2([1, 1]); +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +g3(); +g3([1, 1]); +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +g4(); +g4([1, 1]); +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +g5(); +g5([1, 1]); diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).symbols b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).symbols new file mode 100644 index 0000000000000..17561c8c14d7b --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).symbols @@ -0,0 +1,196 @@ +//// [tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts] //// + +=== destructuringWithLiteralInitializers.ts === +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +>f1 : Symbol(f1, Decl(destructuringWithLiteralInitializers.ts, 0, 0)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 1, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 1, 16)) + +f1({ x: 1, y: 1 }); +>f1 : Symbol(f1, Decl(destructuringWithLiteralInitializers.ts, 0, 0)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 2, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 2, 10)) + +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +>f2 : Symbol(f2, Decl(destructuringWithLiteralInitializers.ts, 2, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 5, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 5, 16)) + +f2({ x: 1 }); +>f2 : Symbol(f2, Decl(destructuringWithLiteralInitializers.ts, 2, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 6, 4)) + +f2({ x: 1, y: 1 }); +>f2 : Symbol(f2, Decl(destructuringWithLiteralInitializers.ts, 2, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 7, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 7, 10)) + +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 10, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 10, 20)) + +f3({}); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) + +f3({ x: 1 }); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 12, 4)) + +f3({ y: 1 }); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 13, 4)) + +f3({ x: 1, y: 1 }); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 14, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 14, 10)) + +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +>f4 : Symbol(f4, Decl(destructuringWithLiteralInitializers.ts, 14, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 17, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 17, 16)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 17, 24)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 17, 30)) + +f4(); +>f4 : Symbol(f4, Decl(destructuringWithLiteralInitializers.ts, 14, 19)) + +f4({ x: 1, y: 1 }); +>f4 : Symbol(f4, Decl(destructuringWithLiteralInitializers.ts, 14, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 19, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 19, 10)) + +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 22, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 22, 16)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 22, 28)) + +f5(); +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) + +f5({ x: 1 }); +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 24, 4)) + +f5({ x: 1, y: 1 }); +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 25, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 25, 10)) + +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 28, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 28, 20)) + +f6(); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) + +f6({}); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) + +f6({ x: 1 }); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 31, 4)) + +f6({ y: 1 }); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 32, 4)) + +f6({ x: 1, y: 1 }); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 33, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 33, 10)) + +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 36, 39)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 36, 18)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 36, 25)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 36, 39)) + +f7(); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) + +f7({ a: {} }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 38, 4)) + +f7({ a: { x: 1 } }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 39, 4)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 39, 9)) + +f7({ a: { y: 1 } }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 40, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 40, 9)) + +f7({ a: { x: 1, y: 1 } }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 41, 4)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 41, 9)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 41, 15)) + +// (arg: [any, any]) => void +function g1([x, y]) { } +>g1 : Symbol(g1, Decl(destructuringWithLiteralInitializers.ts, 41, 26)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 44, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 44, 15)) + +g1([1, 1]); +>g1 : Symbol(g1, Decl(destructuringWithLiteralInitializers.ts, 41, 26)) + +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +>g2 : Symbol(g2, Decl(destructuringWithLiteralInitializers.ts, 45, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 48, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 48, 19)) + +g2([1, 1]); +>g2 : Symbol(g2, Decl(destructuringWithLiteralInitializers.ts, 45, 11)) + +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +>g3 : Symbol(g3, Decl(destructuringWithLiteralInitializers.ts, 49, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 52, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 52, 15)) + +g3(); +>g3 : Symbol(g3, Decl(destructuringWithLiteralInitializers.ts, 49, 11)) + +g3([1, 1]); +>g3 : Symbol(g3, Decl(destructuringWithLiteralInitializers.ts, 49, 11)) + +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +>g4 : Symbol(g4, Decl(destructuringWithLiteralInitializers.ts, 54, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 57, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 57, 15)) + +g4(); +>g4 : Symbol(g4, Decl(destructuringWithLiteralInitializers.ts, 54, 11)) + +g4([1, 1]); +>g4 : Symbol(g4, Decl(destructuringWithLiteralInitializers.ts, 54, 11)) + +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +>g5 : Symbol(g5, Decl(destructuringWithLiteralInitializers.ts, 59, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 62, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 62, 19)) + +g5(); +>g5 : Symbol(g5, Decl(destructuringWithLiteralInitializers.ts, 59, 11)) + +g5([1, 1]); +>g5 : Symbol(g5, Decl(destructuringWithLiteralInitializers.ts, 59, 11)) + diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).types b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).types new file mode 100644 index 0000000000000..d46ab82876d40 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).types @@ -0,0 +1,312 @@ +//// [tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts] //// + +=== destructuringWithLiteralInitializers.ts === +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +>f1 : ({ x, y }: { x: any; y: any; }) => void +>x : any +>y : any + +f1({ x: 1, y: 1 }); +>f1({ x: 1, y: 1 }) : void +>f1 : ({ x, y }: { x: any; y: any; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +>f2 : ({ x, y }: { x: any; y?: number; }) => void +>x : any +>y : number +>0 : 0 + +f2({ x: 1 }); +>f2({ x: 1 }) : void +>f2 : ({ x, y }: { x: any; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f2({ x: 1, y: 1 }); +>f2({ x: 1, y: 1 }) : void +>f2 : ({ x, y }: { x: any; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>x : number +>0 : 0 +>y : number +>0 : 0 + +f3({}); +>f3({}) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{} : {} + +f3({ x: 1 }); +>f3({ x: 1 }) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f3({ y: 1 }); +>f3({ y: 1 }) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{ y: 1 } : { y: number; } +>y : number +>1 : 1 + +f3({ x: 1, y: 1 }); +>f3({ x: 1, y: 1 }) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +>f4 : ({ x, y }?: { x: number; y: number; }) => void +>x : number +>y : number +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + +f4(); +>f4() : void +>f4 : ({ x, y }?: { x: number; y: number; }) => void + +f4({ x: 1, y: 1 }); +>f4({ x: 1, y: 1 }) : void +>f4 : ({ x, y }?: { x: number; y: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +>f5 : ({ x, y }?: { x: number; y?: number; }) => void +>x : number +>y : number +>0 : 0 +>{ x: 0 } : { x: number; } +>x : number +>0 : 0 + +f5(); +>f5() : void +>f5 : ({ x, y }?: { x: number; y?: number; }) => void + +f5({ x: 1 }); +>f5({ x: 1 }) : void +>f5 : ({ x, y }?: { x: number; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f5({ x: 1, y: 1 }); +>f5({ x: 1, y: 1 }) : void +>f5 : ({ x, y }?: { x: number; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>x : number +>0 : 0 +>y : number +>0 : 0 +>{} : {} + +f6(); +>f6() : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void + +f6({}); +>f6({}) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{} : {} + +f6({ x: 1 }); +>f6({ x: 1 }) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f6({ y: 1 }); +>f6({ y: 1 }) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{ y: 1 } : { y: number; } +>y : number +>1 : 1 + +f6({ x: 1, y: 1 }); +>f6({ x: 1, y: 1 }) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>a : any +>x : number +>0 : 0 +>y : number +>0 : 0 +>{ a: {} } : { a: {}; } +>a : {} +>{} : {} + +f7(); +>f7() : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void + +f7({ a: {} }); +>f7({ a: {} }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: {} } : { a: {}; } +>a : {} +>{} : {} + +f7({ a: { x: 1 } }); +>f7({ a: { x: 1 } }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: { x: 1 } } : { a: { x: number; }; } +>a : { x: number; } +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f7({ a: { y: 1 } }); +>f7({ a: { y: 1 } }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: { y: 1 } } : { a: { y: number; }; } +>a : { y: number; } +>{ y: 1 } : { y: number; } +>y : number +>1 : 1 + +f7({ a: { x: 1, y: 1 } }); +>f7({ a: { x: 1, y: 1 } }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: { x: 1, y: 1 } } : { a: { x: number; y: number; }; } +>a : { x: number; y: number; } +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg: [any, any]) => void +function g1([x, y]) { } +>g1 : ([x, y]: [any, any]) => void +>x : any +>y : any + +g1([1, 1]); +>g1([1, 1]) : void +>g1 : ([x, y]: [any, any]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +>g2 : ([x, y]: [number?, number?]) => void +>x : number +>0 : 0 +>y : number +>0 : 0 + +g2([1, 1]); +>g2([1, 1]) : void +>g2 : ([x, y]: [number?, number?]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +>g3 : ([x, y]?: [number, number]) => void +>x : number +>y : number +>[0, 0] : [number, number] +>0 : 0 +>0 : 0 + +g3(); +>g3() : void +>g3 : ([x, y]?: [number, number]) => void + +g3([1, 1]); +>g3([1, 1]) : void +>g3 : ([x, y]?: [number, number]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +>g4 : ([x, y]?: [number, number?]) => void +>x : number +>y : number +>0 : 0 +>[0] : [number] +>0 : 0 + +g4(); +>g4() : void +>g4 : ([x, y]?: [number, number?]) => void + +g4([1, 1]); +>g4([1, 1]) : void +>g4 : ([x, y]?: [number, number?]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +>g5 : ([x, y]?: [number?, number?]) => void +>x : number +>0 : 0 +>y : number +>0 : 0 +>[] : [] + +g5(); +>g5() : void +>g5 : ([x, y]?: [number?, number?]) => void + +g5([1, 1]); +>g5([1, 1]) : void +>g5 : ([x, y]?: [number?, number?]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).js new file mode 100644 index 0000000000000..c76356d188d89 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).js @@ -0,0 +1,126 @@ +//// [tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts] //// + +//// [destructuringWithLiteralInitializers.ts] +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +f1({ x: 1, y: 1 }); + +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +f2({ x: 1 }); +f2({ x: 1, y: 1 }); + +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +f3({}); +f3({ x: 1 }); +f3({ y: 1 }); +f3({ x: 1, y: 1 }); + +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +f4(); +f4({ x: 1, y: 1 }); + +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +f5(); +f5({ x: 1 }); +f5({ x: 1, y: 1 }); + +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +f6(); +f6({}); +f6({ x: 1 }); +f6({ y: 1 }); +f6({ x: 1, y: 1 }); + +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +f7(); +f7({ a: {} }); +f7({ a: { x: 1 } }); +f7({ a: { y: 1 } }); +f7({ a: { x: 1, y: 1 } }); + +// (arg: [any, any]) => void +function g1([x, y]) { } +g1([1, 1]); + +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +g2([1, 1]); + +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +g3(); +g3([1, 1]); + +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +g4(); +g4([1, 1]); + +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +g5(); +g5([1, 1]); + + +//// [destructuringWithLiteralInitializers.js] +"use strict"; +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +f1({ x: 1, y: 1 }); +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +f2({ x: 1 }); +f2({ x: 1, y: 1 }); +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +f3({}); +f3({ x: 1 }); +f3({ y: 1 }); +f3({ x: 1, y: 1 }); +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +f4(); +f4({ x: 1, y: 1 }); +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +f5(); +f5({ x: 1 }); +f5({ x: 1, y: 1 }); +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +f6(); +f6({}); +f6({ x: 1 }); +f6({ y: 1 }); +f6({ x: 1, y: 1 }); +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +f7(); +f7({ a: {} }); +f7({ a: { x: 1 } }); +f7({ a: { y: 1 } }); +f7({ a: { x: 1, y: 1 } }); +// (arg: [any, any]) => void +function g1([x, y]) { } +g1([1, 1]); +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +g2([1, 1]); +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +g3(); +g3([1, 1]); +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +g4(); +g4([1, 1]); +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +g5(); +g5([1, 1]); diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..17561c8c14d7b --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).symbols @@ -0,0 +1,196 @@ +//// [tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts] //// + +=== destructuringWithLiteralInitializers.ts === +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +>f1 : Symbol(f1, Decl(destructuringWithLiteralInitializers.ts, 0, 0)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 1, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 1, 16)) + +f1({ x: 1, y: 1 }); +>f1 : Symbol(f1, Decl(destructuringWithLiteralInitializers.ts, 0, 0)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 2, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 2, 10)) + +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +>f2 : Symbol(f2, Decl(destructuringWithLiteralInitializers.ts, 2, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 5, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 5, 16)) + +f2({ x: 1 }); +>f2 : Symbol(f2, Decl(destructuringWithLiteralInitializers.ts, 2, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 6, 4)) + +f2({ x: 1, y: 1 }); +>f2 : Symbol(f2, Decl(destructuringWithLiteralInitializers.ts, 2, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 7, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 7, 10)) + +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 10, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 10, 20)) + +f3({}); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) + +f3({ x: 1 }); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 12, 4)) + +f3({ y: 1 }); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 13, 4)) + +f3({ x: 1, y: 1 }); +>f3 : Symbol(f3, Decl(destructuringWithLiteralInitializers.ts, 7, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 14, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 14, 10)) + +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +>f4 : Symbol(f4, Decl(destructuringWithLiteralInitializers.ts, 14, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 17, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 17, 16)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 17, 24)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 17, 30)) + +f4(); +>f4 : Symbol(f4, Decl(destructuringWithLiteralInitializers.ts, 14, 19)) + +f4({ x: 1, y: 1 }); +>f4 : Symbol(f4, Decl(destructuringWithLiteralInitializers.ts, 14, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 19, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 19, 10)) + +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 22, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 22, 16)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 22, 28)) + +f5(); +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) + +f5({ x: 1 }); +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 24, 4)) + +f5({ x: 1, y: 1 }); +>f5 : Symbol(f5, Decl(destructuringWithLiteralInitializers.ts, 19, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 25, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 25, 10)) + +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 28, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 28, 20)) + +f6(); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) + +f6({}); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) + +f6({ x: 1 }); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 31, 4)) + +f6({ y: 1 }); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 32, 4)) + +f6({ x: 1, y: 1 }); +>f6 : Symbol(f6, Decl(destructuringWithLiteralInitializers.ts, 25, 19)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 33, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 33, 10)) + +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 36, 39)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 36, 18)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 36, 25)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 36, 39)) + +f7(); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) + +f7({ a: {} }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 38, 4)) + +f7({ a: { x: 1 } }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 39, 4)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 39, 9)) + +f7({ a: { y: 1 } }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 40, 4)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 40, 9)) + +f7({ a: { x: 1, y: 1 } }); +>f7 : Symbol(f7, Decl(destructuringWithLiteralInitializers.ts, 33, 19)) +>a : Symbol(a, Decl(destructuringWithLiteralInitializers.ts, 41, 4)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 41, 9)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 41, 15)) + +// (arg: [any, any]) => void +function g1([x, y]) { } +>g1 : Symbol(g1, Decl(destructuringWithLiteralInitializers.ts, 41, 26)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 44, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 44, 15)) + +g1([1, 1]); +>g1 : Symbol(g1, Decl(destructuringWithLiteralInitializers.ts, 41, 26)) + +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +>g2 : Symbol(g2, Decl(destructuringWithLiteralInitializers.ts, 45, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 48, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 48, 19)) + +g2([1, 1]); +>g2 : Symbol(g2, Decl(destructuringWithLiteralInitializers.ts, 45, 11)) + +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +>g3 : Symbol(g3, Decl(destructuringWithLiteralInitializers.ts, 49, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 52, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 52, 15)) + +g3(); +>g3 : Symbol(g3, Decl(destructuringWithLiteralInitializers.ts, 49, 11)) + +g3([1, 1]); +>g3 : Symbol(g3, Decl(destructuringWithLiteralInitializers.ts, 49, 11)) + +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +>g4 : Symbol(g4, Decl(destructuringWithLiteralInitializers.ts, 54, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 57, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 57, 15)) + +g4(); +>g4 : Symbol(g4, Decl(destructuringWithLiteralInitializers.ts, 54, 11)) + +g4([1, 1]); +>g4 : Symbol(g4, Decl(destructuringWithLiteralInitializers.ts, 54, 11)) + +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +>g5 : Symbol(g5, Decl(destructuringWithLiteralInitializers.ts, 59, 11)) +>x : Symbol(x, Decl(destructuringWithLiteralInitializers.ts, 62, 13)) +>y : Symbol(y, Decl(destructuringWithLiteralInitializers.ts, 62, 19)) + +g5(); +>g5 : Symbol(g5, Decl(destructuringWithLiteralInitializers.ts, 59, 11)) + +g5([1, 1]); +>g5 : Symbol(g5, Decl(destructuringWithLiteralInitializers.ts, 59, 11)) + diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types new file mode 100644 index 0000000000000..d46ab82876d40 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types @@ -0,0 +1,312 @@ +//// [tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts] //// + +=== destructuringWithLiteralInitializers.ts === +// (arg: { x: any, y: any }) => void +function f1({ x, y }) { } +>f1 : ({ x, y }: { x: any; y: any; }) => void +>x : any +>y : any + +f1({ x: 1, y: 1 }); +>f1({ x: 1, y: 1 }) : void +>f1 : ({ x, y }: { x: any; y: any; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg: { x: any, y?: number }) => void +function f2({ x, y = 0 }) { } +>f2 : ({ x, y }: { x: any; y?: number; }) => void +>x : any +>y : number +>0 : 0 + +f2({ x: 1 }); +>f2({ x: 1 }) : void +>f2 : ({ x, y }: { x: any; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f2({ x: 1, y: 1 }); +>f2({ x: 1, y: 1 }) : void +>f2 : ({ x, y }: { x: any; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg: { x?: number, y?: number }) => void +function f3({ x = 0, y = 0 }) { } +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>x : number +>0 : 0 +>y : number +>0 : 0 + +f3({}); +>f3({}) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{} : {} + +f3({ x: 1 }); +>f3({ x: 1 }) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f3({ y: 1 }); +>f3({ y: 1 }) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{ y: 1 } : { y: number; } +>y : number +>1 : 1 + +f3({ x: 1, y: 1 }); +>f3({ x: 1, y: 1 }) : void +>f3 : ({ x, y }: { x?: number; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { x: number, y: number }) => void +function f4({ x, y } = { x: 0, y: 0 }) { } +>f4 : ({ x, y }?: { x: number; y: number; }) => void +>x : number +>y : number +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + +f4(); +>f4() : void +>f4 : ({ x, y }?: { x: number; y: number; }) => void + +f4({ x: 1, y: 1 }); +>f4({ x: 1, y: 1 }) : void +>f4 : ({ x, y }?: { x: number; y: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { x: number, y?: number }) => void +function f5({ x, y = 0 } = { x: 0 }) { } +>f5 : ({ x, y }?: { x: number; y?: number; }) => void +>x : number +>y : number +>0 : 0 +>{ x: 0 } : { x: number; } +>x : number +>0 : 0 + +f5(); +>f5() : void +>f5 : ({ x, y }?: { x: number; y?: number; }) => void + +f5({ x: 1 }); +>f5({ x: 1 }) : void +>f5 : ({ x, y }?: { x: number; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f5({ x: 1, y: 1 }); +>f5({ x: 1, y: 1 }) : void +>f5 : ({ x, y }?: { x: number; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { x?: number, y?: number }) => void +function f6({ x = 0, y = 0 } = {}) { } +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>x : number +>0 : 0 +>y : number +>0 : 0 +>{} : {} + +f6(); +>f6() : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void + +f6({}); +>f6({}) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{} : {} + +f6({ x: 1 }); +>f6({ x: 1 }) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f6({ y: 1 }); +>f6({ y: 1 }) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{ y: 1 } : { y: number; } +>y : number +>1 : 1 + +f6({ x: 1, y: 1 }); +>f6({ x: 1, y: 1 }) : void +>f6 : ({ x, y }?: { x?: number; y?: number; }) => void +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg?: { a: { x?: number, y?: number } }) => void +function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>a : any +>x : number +>0 : 0 +>y : number +>0 : 0 +>{ a: {} } : { a: {}; } +>a : {} +>{} : {} + +f7(); +>f7() : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void + +f7({ a: {} }); +>f7({ a: {} }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: {} } : { a: {}; } +>a : {} +>{} : {} + +f7({ a: { x: 1 } }); +>f7({ a: { x: 1 } }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: { x: 1 } } : { a: { x: number; }; } +>a : { x: number; } +>{ x: 1 } : { x: number; } +>x : number +>1 : 1 + +f7({ a: { y: 1 } }); +>f7({ a: { y: 1 } }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: { y: 1 } } : { a: { y: number; }; } +>a : { y: number; } +>{ y: 1 } : { y: number; } +>y : number +>1 : 1 + +f7({ a: { x: 1, y: 1 } }); +>f7({ a: { x: 1, y: 1 } }) : void +>f7 : ({ a: { x, y } }?: { a: {}; }) => void +>{ a: { x: 1, y: 1 } } : { a: { x: number; y: number; }; } +>a : { x: number; y: number; } +>{ x: 1, y: 1 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>1 : 1 + +// (arg: [any, any]) => void +function g1([x, y]) { } +>g1 : ([x, y]: [any, any]) => void +>x : any +>y : any + +g1([1, 1]); +>g1([1, 1]) : void +>g1 : ([x, y]: [any, any]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg: [number, number]) => void +function g2([x = 0, y = 0]) { } +>g2 : ([x, y]: [number?, number?]) => void +>x : number +>0 : 0 +>y : number +>0 : 0 + +g2([1, 1]); +>g2([1, 1]) : void +>g2 : ([x, y]: [number?, number?]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg?: [number, number]) => void +function g3([x, y] = [0, 0]) { } +>g3 : ([x, y]?: [number, number]) => void +>x : number +>y : number +>[0, 0] : [number, number] +>0 : 0 +>0 : 0 + +g3(); +>g3() : void +>g3 : ([x, y]?: [number, number]) => void + +g3([1, 1]); +>g3([1, 1]) : void +>g3 : ([x, y]?: [number, number]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg?: [number, number]) => void +function g4([x, y = 0] = [0]) { } +>g4 : ([x, y]?: [number, number?]) => void +>x : number +>y : number +>0 : 0 +>[0] : [number] +>0 : 0 + +g4(); +>g4() : void +>g4 : ([x, y]?: [number, number?]) => void + +g4([1, 1]); +>g4([1, 1]) : void +>g4 : ([x, y]?: [number, number?]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + +// (arg?: [number, number]) => void +function g5([x = 0, y = 0] = []) { } +>g5 : ([x, y]?: [number?, number?]) => void +>x : number +>0 : 0 +>y : number +>0 : 0 +>[] : [] + +g5(); +>g5() : void +>g5 : ([x, y]?: [number?, number?]) => void + +g5([1, 1]); +>g5([1, 1]) : void +>g5 : ([x, y]?: [number?, number?]) => void +>[1, 1] : [number, number] +>1 : 1 +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).errors.txt new file mode 100644 index 0000000000000..3427c0e358148 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).errors.txt @@ -0,0 +1,16 @@ +/foo.js(1,15): error TS1005: 'from' expected. +/foo.js(1,15): error TS1141: String literal expected. + + +==== /foo.js (2 errors) ==== + /** @import x = require("types") */ + ~ +!!! error TS1005: 'from' expected. + ~~~~~~~~~~~~~~~~~~ +!!! error TS1141: String literal expected. + +==== /types.ts (0 errors) ==== + export interface Foo { + a: number; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).symbols b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).symbols new file mode 100644 index 0000000000000..fbc59963b3da9 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).symbols @@ -0,0 +1,6 @@ +//// [tests/cases/conformance/jsdoc/importTag13.ts] //// + +=== /foo.js === + +/** @import x = require("types") */ + diff --git a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).types b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).types new file mode 100644 index 0000000000000..fbc59963b3da9 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).types @@ -0,0 +1,6 @@ +//// [tests/cases/conformance/jsdoc/importTag13.ts] //// + +=== /foo.js === + +/** @import x = require("types") */ + diff --git a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..3427c0e358148 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +/foo.js(1,15): error TS1005: 'from' expected. +/foo.js(1,15): error TS1141: String literal expected. + + +==== /foo.js (2 errors) ==== + /** @import x = require("types") */ + ~ +!!! error TS1005: 'from' expected. + ~~~~~~~~~~~~~~~~~~ +!!! error TS1141: String literal expected. + +==== /types.ts (0 errors) ==== + export interface Foo { + a: number; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..fbc59963b3da9 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).symbols @@ -0,0 +1,6 @@ +//// [tests/cases/conformance/jsdoc/importTag13.ts] //// + +=== /foo.js === + +/** @import x = require("types") */ + diff --git a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).types new file mode 100644 index 0000000000000..fbc59963b3da9 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).types @@ -0,0 +1,6 @@ +//// [tests/cases/conformance/jsdoc/importTag13.ts] //// + +=== /foo.js === + +/** @import x = require("types") */ + diff --git a/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt b/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt index 4534e059f31e9..18f6e68c68b55 100644 --- a/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt @@ -1,14 +1,11 @@ parser519458.ts(1,15): error TS2503: Cannot find namespace 'module'. -parser519458.ts(1,15): error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. parser519458.ts(1,21): error TS1005: ';' expected. -==== parser519458.ts (3 errors) ==== +==== parser519458.ts (2 errors) ==== import rect = module("rect"); var bar = new rect.Rect(); ~~~~~~ !!! error TS2503: Cannot find namespace 'module'. - ~~~~~~ -!!! error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. ~ !!! error TS1005: ';' expected. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).errors.txt new file mode 100644 index 0000000000000..634c2349e1ecb --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).errors.txt @@ -0,0 +1,23 @@ +privateNameNestedClassFieldShadowing.ts(7,31): error TS18014: The property '#x' cannot be accessed on type 'Base' within this class because it is shadowed by another private identifier with the same spelling. + + +==== privateNameNestedClassFieldShadowing.ts (1 errors) ==== + class Base { + #x; + constructor() { + class Derived { + #x; + testBase(x: Base) { + console.log(x.#x); + ~~ +!!! error TS18014: The property '#x' cannot be accessed on type 'Base' within this class because it is shadowed by another private identifier with the same spelling. +!!! related TS18017 privateNameNestedClassFieldShadowing.ts:5:13: The shadowing declaration of '#x' is defined here +!!! related TS18018 privateNameNestedClassFieldShadowing.ts:2:5: The declaration of '#x' that you probably intended to use is defined here + } + testDerived(x: Derived) { + console.log(x.#x); + } + } + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).js b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).js new file mode 100644 index 0000000000000..4e0c843d1ebc9 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).js @@ -0,0 +1,46 @@ +//// [tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts] //// + +//// [privateNameNestedClassFieldShadowing.ts] +class Base { + #x; + constructor() { + class Derived { + #x; + testBase(x: Base) { + console.log(x.#x); + } + testDerived(x: Derived) { + console.log(x.#x); + } + } + } +} + + +//// [privateNameNestedClassFieldShadowing.js] +"use strict"; +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _Base_x; +class Base { + constructor() { + var _Derived_x; + _Base_x.set(this, void 0); + class Derived { + constructor() { + _Derived_x.set(this, void 0); + } + testBase(x) { + console.log(__classPrivateFieldGet(x, _Derived_x, "f")); + } + testDerived(x) { + console.log(__classPrivateFieldGet(x, _Derived_x, "f")); + } + } + _Derived_x = new WeakMap(); + } +} +_Base_x = new WeakMap(); diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).symbols b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).symbols new file mode 100644 index 0000000000000..33cee0bc25f14 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).symbols @@ -0,0 +1,43 @@ +//// [tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts] //// + +=== privateNameNestedClassFieldShadowing.ts === +class Base { +>Base : Symbol(Base, Decl(privateNameNestedClassFieldShadowing.ts, 0, 0)) + + #x; +>#x : Symbol(Base.#x, Decl(privateNameNestedClassFieldShadowing.ts, 0, 12)) + + constructor() { + class Derived { +>Derived : Symbol(Derived, Decl(privateNameNestedClassFieldShadowing.ts, 2, 19)) + + #x; +>#x : Symbol(Derived.#x, Decl(privateNameNestedClassFieldShadowing.ts, 3, 23)) + + testBase(x: Base) { +>testBase : Symbol(Derived.testBase, Decl(privateNameNestedClassFieldShadowing.ts, 4, 15)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 5, 21)) +>Base : Symbol(Base, Decl(privateNameNestedClassFieldShadowing.ts, 0, 0)) + + console.log(x.#x); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 5, 21)) + } + testDerived(x: Derived) { +>testDerived : Symbol(Derived.testDerived, Decl(privateNameNestedClassFieldShadowing.ts, 7, 13)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 8, 24)) +>Derived : Symbol(Derived, Decl(privateNameNestedClassFieldShadowing.ts, 2, 19)) + + console.log(x.#x); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>x.#x : Symbol(Derived.#x, Decl(privateNameNestedClassFieldShadowing.ts, 3, 23)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 8, 24)) + } + } + } +} + diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).types b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).types new file mode 100644 index 0000000000000..473319eee8b31 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).types @@ -0,0 +1,44 @@ +//// [tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts] //// + +=== privateNameNestedClassFieldShadowing.ts === +class Base { +>Base : Base + + #x; +>#x : any + + constructor() { + class Derived { +>Derived : Derived + + #x; +>#x : any + + testBase(x: Base) { +>testBase : (x: Base) => void +>x : Base + + console.log(x.#x); +>console.log(x.#x) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>x.#x : any +>x : Base + } + testDerived(x: Derived) { +>testDerived : (x: Derived) => void +>x : Derived + + console.log(x.#x); +>console.log(x.#x) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>x.#x : any +>x : Derived + } + } + } +} + diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..634c2349e1ecb --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt @@ -0,0 +1,23 @@ +privateNameNestedClassFieldShadowing.ts(7,31): error TS18014: The property '#x' cannot be accessed on type 'Base' within this class because it is shadowed by another private identifier with the same spelling. + + +==== privateNameNestedClassFieldShadowing.ts (1 errors) ==== + class Base { + #x; + constructor() { + class Derived { + #x; + testBase(x: Base) { + console.log(x.#x); + ~~ +!!! error TS18014: The property '#x' cannot be accessed on type 'Base' within this class because it is shadowed by another private identifier with the same spelling. +!!! related TS18017 privateNameNestedClassFieldShadowing.ts:5:13: The shadowing declaration of '#x' is defined here +!!! related TS18018 privateNameNestedClassFieldShadowing.ts:2:5: The declaration of '#x' that you probably intended to use is defined here + } + testDerived(x: Derived) { + console.log(x.#x); + } + } + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).js new file mode 100644 index 0000000000000..4e0c843d1ebc9 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).js @@ -0,0 +1,46 @@ +//// [tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts] //// + +//// [privateNameNestedClassFieldShadowing.ts] +class Base { + #x; + constructor() { + class Derived { + #x; + testBase(x: Base) { + console.log(x.#x); + } + testDerived(x: Derived) { + console.log(x.#x); + } + } + } +} + + +//// [privateNameNestedClassFieldShadowing.js] +"use strict"; +var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _Base_x; +class Base { + constructor() { + var _Derived_x; + _Base_x.set(this, void 0); + class Derived { + constructor() { + _Derived_x.set(this, void 0); + } + testBase(x) { + console.log(__classPrivateFieldGet(x, _Derived_x, "f")); + } + testDerived(x) { + console.log(__classPrivateFieldGet(x, _Derived_x, "f")); + } + } + _Derived_x = new WeakMap(); + } +} +_Base_x = new WeakMap(); diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..33cee0bc25f14 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).symbols @@ -0,0 +1,43 @@ +//// [tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts] //// + +=== privateNameNestedClassFieldShadowing.ts === +class Base { +>Base : Symbol(Base, Decl(privateNameNestedClassFieldShadowing.ts, 0, 0)) + + #x; +>#x : Symbol(Base.#x, Decl(privateNameNestedClassFieldShadowing.ts, 0, 12)) + + constructor() { + class Derived { +>Derived : Symbol(Derived, Decl(privateNameNestedClassFieldShadowing.ts, 2, 19)) + + #x; +>#x : Symbol(Derived.#x, Decl(privateNameNestedClassFieldShadowing.ts, 3, 23)) + + testBase(x: Base) { +>testBase : Symbol(Derived.testBase, Decl(privateNameNestedClassFieldShadowing.ts, 4, 15)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 5, 21)) +>Base : Symbol(Base, Decl(privateNameNestedClassFieldShadowing.ts, 0, 0)) + + console.log(x.#x); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 5, 21)) + } + testDerived(x: Derived) { +>testDerived : Symbol(Derived.testDerived, Decl(privateNameNestedClassFieldShadowing.ts, 7, 13)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 8, 24)) +>Derived : Symbol(Derived, Decl(privateNameNestedClassFieldShadowing.ts, 2, 19)) + + console.log(x.#x); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>x.#x : Symbol(Derived.#x, Decl(privateNameNestedClassFieldShadowing.ts, 3, 23)) +>x : Symbol(x, Decl(privateNameNestedClassFieldShadowing.ts, 8, 24)) + } + } + } +} + diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).types new file mode 100644 index 0000000000000..473319eee8b31 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).types @@ -0,0 +1,44 @@ +//// [tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts] //// + +=== privateNameNestedClassFieldShadowing.ts === +class Base { +>Base : Base + + #x; +>#x : any + + constructor() { + class Derived { +>Derived : Derived + + #x; +>#x : any + + testBase(x: Base) { +>testBase : (x: Base) => void +>x : Base + + console.log(x.#x); +>console.log(x.#x) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>x.#x : any +>x : Base + } + testDerived(x: Derived) { +>testDerived : (x: Derived) => void +>x : Derived + + console.log(x.#x); +>console.log(x.#x) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>x.#x : any +>x : Derived + } + } + } +} + diff --git a/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt b/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt index 5d6e45f1ffa2e..802cc83bd228b 100644 --- a/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt @@ -4,12 +4,14 @@ recursiveMappedTypes.ts(7,6): error TS2456: Type alias 'Recurse1' circularly ref recursiveMappedTypes.ts(8,11): error TS2313: Type parameter 'K' has a circular constraint. recursiveMappedTypes.ts(11,6): error TS2456: Type alias 'Recurse2' circularly references itself. recursiveMappedTypes.ts(12,11): error TS2313: Type parameter 'K' has a circular constraint. -recursiveMappedTypes.ts(20,19): error TS5114: Instantiations of type 'Circular' appear infinitely circular. +recursiveMappedTypes.ts(20,14): error TS2589: Type instantiation is excessively deep and possibly infinite. +recursiveMappedTypes.ts(20,19): error TS2589: Type instantiation is excessively deep and possibly infinite. +recursiveMappedTypes.ts(21,10): error TS2589: Type instantiation is excessively deep and possibly infinite. recursiveMappedTypes.ts(73,5): error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. -recursiveMappedTypes.ts(79,1): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. +recursiveMappedTypes.ts(73,13): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; minimum_count: "minimum_count"; maximum_count: "maximum_count"; collapsable?: undefined; each: any; }'. -==== recursiveMappedTypes.ts (9 errors) ==== +==== recursiveMappedTypes.ts (11 errors) ==== // Recursive mapped types simply appear empty type Recurse = { @@ -34,7 +36,6 @@ recursiveMappedTypes.ts(79,1): error TS2615: Type of property '"each"' circularl [K in keyof Recurse1]: Recurse1[K] ~~~~~~~~~~~~~~ !!! error TS2313: Type parameter 'K' has a circular constraint. -!!! related TS2751 recursiveMappedTypes.ts:8:17: Circularity originates in type at this location. } // Repro from #27881 @@ -43,9 +44,13 @@ recursiveMappedTypes.ts(79,1): error TS2615: Type of property '"each"' circularl type tup = [number, number, number, number]; function foo(arg: Circular): tup { + ~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Circular' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. return arg; + ~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. } // Repro from #29442 @@ -100,14 +105,14 @@ recursiveMappedTypes.ts(79,1): error TS2615: Type of property '"each"' circularl "each": Child; ~~~~~~ !!! error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. + ~~~~~~~~~~~~~~~~~ +!!! error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; minimum_count: "minimum_count"; maximum_count: "maximum_count"; collapsable?: undefined; each: any; }'. } type ListChild = Child declare let x: ListChild; x.type; - ~ -!!! error TS2615: Type of property '"each"' circularly references itself in mapped type '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. // Repros from #41790 diff --git a/tsc/testdata/baselines/reference/conformance/spreadUnion.types b/tsc/testdata/baselines/reference/conformance/spreadUnion.types index a19bbca939f5d..d74f767c4a624 100644 --- a/tsc/testdata/baselines/reference/conformance/spreadUnion.types +++ b/tsc/testdata/baselines/reference/conformance/spreadUnion.types @@ -38,7 +38,7 @@ var o5: { a: number } | { b: string } | { a: number, b: string }; var o5 = { ...union, ...union }; >o5 : { a: number; } | { b: string; } | { a: number; b: string; } ->{ ...union, ...union } : { a: number; } | { a: number; b: string; } | { a: number; b: string; } | { b: string; } +>{ ...union, ...union } : { a: number; } | { b: string; } | { a: number; b: string; } | { a: number; b: string; } >union : { a: number; } | { b: string; } >union : { a: number; } | { b: string; } diff --git a/tsc/testdata/baselines/reference/conformance/templateLiteralTypes1.errors.txt b/tsc/testdata/baselines/reference/conformance/templateLiteralTypes1.errors.txt index ed921a5dbfe66..a77ac80910723 100644 --- a/tsc/testdata/baselines/reference/conformance/templateLiteralTypes1.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/templateLiteralTypes1.errors.txt @@ -6,10 +6,13 @@ templateLiteralTypes1.ts(165,15): error TS1338: 'infer' declarations are only pe templateLiteralTypes1.ts(197,16): error TS2590: Expression produces a union type that is too complex to represent. templateLiteralTypes1.ts(201,16): error TS2590: Expression produces a union type that is too complex to represent. templateLiteralTypes1.ts(205,16): error TS2590: Expression produces a union type that is too complex to represent. +templateLiteralTypes1.ts(250,5): error TS2590: Expression produces a union type that is too complex to represent. templateLiteralTypes1.ts(252,7): error TS2590: Expression produces a union type that is too complex to represent. +templateLiteralTypes1.ts(254,7): error TS2590: Expression produces a union type that is too complex to represent. +templateLiteralTypes1.ts(254,14): error TS2590: Expression produces a union type that is too complex to represent. -==== templateLiteralTypes1.ts (7 errors) ==== +==== templateLiteralTypes1.ts (10 errors) ==== // Template types example from #12754 const createScopedActionType = (scope: S) => (type: T) => `${scope}/${type}` as `${S}/${T}`; @@ -275,10 +278,18 @@ templateLiteralTypes1.ts(252,7): error TS2590: Expression produces a union type export type SpacingShorthand = | `${Spacing} ${Spacing}` + ~~~~~~~~~~~~~~~~~~~~~~~~~ | `${Spacing} ${Spacing} ${Spacing}` + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | `${Spacing} ${Spacing} ${Spacing} ${Spacing}`; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2590: Expression produces a union type that is too complex to represent. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2590: Expression produces a union type that is too complex to represent. const test1: SpacingShorthand = "0 0 0"; + ~~~~~ +!!! error TS2590: Expression produces a union type that is too complex to represent. + ~~~~~~~~~~~~~~~~ +!!! error TS2590: Expression produces a union type that is too complex to represent. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt b/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt index c0edb81a0dde9..f3f7dedc9700c 100644 --- a/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt @@ -79,6 +79,7 @@ thisTypeInFunctionsNegative.ts(169,23): error TS1359: Identifier expected. 'this thisTypeInFunctionsNegative.ts(169,23): error TS2680: A 'this' parameter must be the first parameter. thisTypeInFunctionsNegative.ts(170,23): error TS1005: ',' expected. thisTypeInFunctionsNegative.ts(171,20): error TS1433: Neither decorators nor modifiers may be applied to 'this' parameters. +thisTypeInFunctionsNegative.ts(171,21): error TS2304: Cannot find name 'deco'. thisTypeInFunctionsNegative.ts(172,30): error TS1005: ',' expected. thisTypeInFunctionsNegative.ts(172,32): error TS1359: Identifier expected. 'new' is a reserved word that cannot be used here. thisTypeInFunctionsNegative.ts(172,37): error TS1005: ',' expected. @@ -93,7 +94,7 @@ thisTypeInFunctionsNegative.ts(177,19): error TS2730: An arrow function cannot h thisTypeInFunctionsNegative.ts(178,22): error TS2730: An arrow function cannot have a 'this' parameter. -==== thisTypeInFunctionsNegative.ts (63 errors) ==== +==== thisTypeInFunctionsNegative.ts (64 errors) ==== class C { n: number; explicitThis(this: this, m: number): number { @@ -407,6 +408,8 @@ thisTypeInFunctionsNegative.ts(178,22): error TS2730: An arrow function cannot h function decorated(@deco() this: C): number { return this.n; } ~~~~~~~ !!! error TS1433: Neither decorators nor modifiers may be applied to 'this' parameters. + ~~~~ +!!! error TS2304: Cannot find name 'deco'. function initializer(this: C = new C()): number { return this.n; } ~ !!! error TS1005: ',' expected. diff --git a/tsc/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsObjectBindingElementPropertyName05.baseline.jsonc b/tsc/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsObjectBindingElementPropertyName05.baseline.jsonc index fc60af735d4e3..8eea46177cedb 100644 --- a/tsc/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsObjectBindingElementPropertyName05.baseline.jsonc +++ b/tsc/testdata/baselines/reference/fourslash/findAllReferences/findAllRefsObjectBindingElementPropertyName05.baseline.jsonc @@ -5,6 +5,6 @@ // property2: string; // } // -// function f({ /*FIND ALL REFS*/property1: p }, { property1 }) { +// function f({ /*FIND ALL REFS*/[|property1|]: p }, { property1 }) { // let x = property1; // } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js index c2fc8d7b618c1..c636506b065dd 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js @@ -230,77 +230,77 @@ export declare const w: { {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"X","recursionId":76,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, -{"id":83,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":84,"recursionId":78,"keyofType":82,"flags":["Index"]}, -{"id":85,"symbolName":"__type","recursionId":79,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":86,"recursionId":76,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, -{"id":87,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":88,"symbolName":"SymbolConstructor","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":89,"symbolName":"toStringTag","recursionId":82,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":90,"symbolName":"expand","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, -{"id":91,"symbolName":"C","recursionId":84,"instantiatedType":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, -{"id":92,"symbolName":"C","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, -{"id":93,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":94,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":95,"recursionId":85,"keyofType":91,"flags":["Index"]}, -{"id":96,"symbolName":"__type","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":11},"end":{"line":3,"character":19}},"flags":["Object"],"display":"{ a: 1; }"}, -{"id":97,"symbolName":"__type","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":9},"end":{"line":4,"character":18}},"flags":["Object"],"display":"{ p1: 1; }"}, -{"id":98,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":9},"end":{"line":5,"character":18}},"flags":["Object"],"display":"{ p2: 2; }"}, -{"id":99,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":9},"end":{"line":6,"character":18}},"flags":["Object"],"display":"{ p3: 3; }"}, -{"id":100,"symbolName":"__type","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":9},"end":{"line":7,"character":18}},"flags":["Object"],"display":"{ p4: 4; }"}, -{"id":101,"symbolName":"__type","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":9},"end":{"line":8,"character":18}},"flags":["Object"],"display":"{ p5: 5; }"}, -{"id":102,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":9},"end":{"line":9,"character":18}},"flags":["Object"],"display":"{ p6: 6; }"}, -{"id":103,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":9},"end":{"line":10,"character":18}},"flags":["Object"],"display":"{ p7: 7; }"}, -{"id":104,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":9},"end":{"line":11,"character":18}},"flags":["Object"],"display":"{ p8: 8; }"}, -{"id":105,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":9},"end":{"line":12,"character":18}},"flags":["Object"],"display":"{ p9: 9; }"}, -{"id":106,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":10},"end":{"line":13,"character":21}},"flags":["Object"],"display":"{ p10: 10; }"}, -{"id":107,"recursionId":97,"flags":["NumberLiteral"],"display":"10"}, -{"id":108,"recursionId":98,"flags":["NumberLiteral"],"display":"10"}, -{"id":109,"recursionId":99,"flags":["NumberLiteral"],"display":"9"}, -{"id":110,"recursionId":100,"flags":["NumberLiteral"],"display":"9"}, -{"id":111,"recursionId":101,"flags":["NumberLiteral"],"display":"8"}, -{"id":112,"recursionId":102,"flags":["NumberLiteral"],"display":"8"}, -{"id":113,"recursionId":103,"flags":["NumberLiteral"],"display":"7"}, -{"id":114,"recursionId":104,"flags":["NumberLiteral"],"display":"7"}, -{"id":115,"recursionId":105,"flags":["NumberLiteral"],"display":"6"}, -{"id":116,"recursionId":106,"flags":["NumberLiteral"],"display":"6"}, -{"id":117,"recursionId":107,"flags":["NumberLiteral"],"display":"5"}, -{"id":118,"recursionId":108,"flags":["NumberLiteral"],"display":"5"}, -{"id":119,"recursionId":109,"flags":["NumberLiteral"],"display":"4"}, -{"id":120,"recursionId":110,"flags":["NumberLiteral"],"display":"4"}, -{"id":121,"recursionId":111,"flags":["NumberLiteral"],"display":"3"}, -{"id":122,"recursionId":112,"flags":["NumberLiteral"],"display":"3"}, -{"id":123,"recursionId":113,"flags":["NumberLiteral"],"display":"2"}, -{"id":124,"recursionId":114,"flags":["NumberLiteral"],"display":"2"}, -{"id":125,"recursionId":115,"flags":["NumberLiteral"],"display":"1"}, -{"id":126,"recursionId":116,"flags":["NumberLiteral"],"display":"1"}, -{"id":127,"recursionId":117,"unionTypes":[96,97,98,99,100,101,102,103,104,105,106],"flags":["Union"],"display":"{ a: 1; } | { p1: 1; } | { p2: 2; } | { p3: 3; } | { p4: 4; } | { p5: 5; } | { p6: 6; } | { p7: 7; } | { p8: 8; } | { p9: 9; } | { p10: 10; }"}, -{"id":128,"recursionId":118,"flags":["StringLiteral"],"display":"\"m1\""}, -{"id":129,"recursionId":119,"flags":["StringLiteral"],"display":"\"m2\""}, -{"id":130,"recursionId":120,"flags":["StringLiteral"],"display":"\"m3\""}, -{"id":131,"recursionId":121,"flags":["StringLiteral"],"display":"\"m4\""}, -{"id":132,"recursionId":122,"flags":["StringLiteral"],"display":"\"m5\""}, -{"id":133,"recursionId":123,"flags":["StringLiteral"],"display":"\"m6\""}, -{"id":134,"recursionId":124,"flags":["StringLiteral"],"display":"\"m7\""}, -{"id":135,"recursionId":125,"flags":["StringLiteral"],"display":"\"m8\""}, -{"id":136,"recursionId":126,"flags":["StringLiteral"],"display":"\"m9\""}, -{"id":137,"recursionId":127,"flags":["StringLiteral"],"display":"\"m10\""}, -{"id":138,"recursionId":128,"unionTypes":[14,15],"flags":["Union"],"display":"keyof C"}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"X","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, +{"id":83,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":84,"recursionId":83,"keyofType":82,"flags":["Index"]}, +{"id":85,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":86,"recursionId":81,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, +{"id":87,"symbolName":"Symbol","recursionId":85,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":88,"symbolName":"SymbolConstructor","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":89,"symbolName":"toStringTag","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":90,"symbolName":"expand","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, +{"id":91,"symbolName":"C","recursionId":89,"instantiatedType":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, +{"id":92,"symbolName":"C","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, +{"id":93,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":94,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":95,"recursionId":91,"keyofType":91,"flags":["Index"]}, +{"id":96,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":11},"end":{"line":3,"character":19}},"flags":["Object"],"display":"{ a: 1; }"}, +{"id":97,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":9},"end":{"line":4,"character":18}},"flags":["Object"],"display":"{ p1: 1; }"}, +{"id":98,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":9},"end":{"line":5,"character":18}},"flags":["Object"],"display":"{ p2: 2; }"}, +{"id":99,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":9},"end":{"line":6,"character":18}},"flags":["Object"],"display":"{ p3: 3; }"}, +{"id":100,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":9},"end":{"line":7,"character":18}},"flags":["Object"],"display":"{ p4: 4; }"}, +{"id":101,"symbolName":"__type","recursionId":97,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":9},"end":{"line":8,"character":18}},"flags":["Object"],"display":"{ p5: 5; }"}, +{"id":102,"symbolName":"__type","recursionId":98,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":9},"end":{"line":9,"character":18}},"flags":["Object"],"display":"{ p6: 6; }"}, +{"id":103,"symbolName":"__type","recursionId":99,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":9},"end":{"line":10,"character":18}},"flags":["Object"],"display":"{ p7: 7; }"}, +{"id":104,"symbolName":"__type","recursionId":100,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":9},"end":{"line":11,"character":18}},"flags":["Object"],"display":"{ p8: 8; }"}, +{"id":105,"symbolName":"__type","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":9},"end":{"line":12,"character":18}},"flags":["Object"],"display":"{ p9: 9; }"}, +{"id":106,"symbolName":"__type","recursionId":102,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":10},"end":{"line":13,"character":21}},"flags":["Object"],"display":"{ p10: 10; }"}, +{"id":107,"recursionId":103,"flags":["NumberLiteral"],"display":"10"}, +{"id":108,"recursionId":104,"flags":["NumberLiteral"],"display":"10"}, +{"id":109,"recursionId":105,"flags":["NumberLiteral"],"display":"9"}, +{"id":110,"recursionId":106,"flags":["NumberLiteral"],"display":"9"}, +{"id":111,"recursionId":107,"flags":["NumberLiteral"],"display":"8"}, +{"id":112,"recursionId":108,"flags":["NumberLiteral"],"display":"8"}, +{"id":113,"recursionId":109,"flags":["NumberLiteral"],"display":"7"}, +{"id":114,"recursionId":110,"flags":["NumberLiteral"],"display":"7"}, +{"id":115,"recursionId":111,"flags":["NumberLiteral"],"display":"6"}, +{"id":116,"recursionId":112,"flags":["NumberLiteral"],"display":"6"}, +{"id":117,"recursionId":113,"flags":["NumberLiteral"],"display":"5"}, +{"id":118,"recursionId":114,"flags":["NumberLiteral"],"display":"5"}, +{"id":119,"recursionId":115,"flags":["NumberLiteral"],"display":"4"}, +{"id":120,"recursionId":116,"flags":["NumberLiteral"],"display":"4"}, +{"id":121,"recursionId":117,"flags":["NumberLiteral"],"display":"3"}, +{"id":122,"recursionId":118,"flags":["NumberLiteral"],"display":"3"}, +{"id":123,"recursionId":119,"flags":["NumberLiteral"],"display":"2"}, +{"id":124,"recursionId":120,"flags":["NumberLiteral"],"display":"2"}, +{"id":125,"recursionId":121,"flags":["NumberLiteral"],"display":"1"}, +{"id":126,"recursionId":122,"flags":["NumberLiteral"],"display":"1"}, +{"id":127,"recursionId":123,"unionTypes":[96,97,98,99,100,101,102,103,104,105,106],"flags":["Union"],"display":"{ a: 1; } | { p1: 1; } | { p2: 2; } | { p3: 3; } | { p4: 4; } | { p5: 5; } | { p6: 6; } | { p7: 7; } | { p8: 8; } | { p9: 9; } | { p10: 10; }"}, +{"id":128,"recursionId":124,"flags":["StringLiteral"],"display":"\"m1\""}, +{"id":129,"recursionId":125,"flags":["StringLiteral"],"display":"\"m2\""}, +{"id":130,"recursionId":126,"flags":["StringLiteral"],"display":"\"m3\""}, +{"id":131,"recursionId":127,"flags":["StringLiteral"],"display":"\"m4\""}, +{"id":132,"recursionId":128,"flags":["StringLiteral"],"display":"\"m5\""}, +{"id":133,"recursionId":129,"flags":["StringLiteral"],"display":"\"m6\""}, +{"id":134,"recursionId":130,"flags":["StringLiteral"],"display":"\"m7\""}, +{"id":135,"recursionId":131,"flags":["StringLiteral"],"display":"\"m8\""}, +{"id":136,"recursionId":132,"flags":["StringLiteral"],"display":"\"m9\""}, +{"id":137,"recursionId":133,"flags":["StringLiteral"],"display":"\"m10\""}, +{"id":138,"recursionId":134,"unionTypes":[14,15],"flags":["Union"],"display":"keyof C"}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js index 91ed1755c8ff3..bed3ae67e51e0 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js @@ -209,76 +209,76 @@ export declare const w: { {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"X","recursionId":76,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, -{"id":83,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":84,"recursionId":78,"keyofType":82,"flags":["Index"]}, -{"id":85,"symbolName":"__type","recursionId":79,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":86,"recursionId":76,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, -{"id":87,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":88,"symbolName":"SymbolConstructor","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":89,"symbolName":"toStringTag","recursionId":82,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":90,"symbolName":"expand","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, -{"id":91,"symbolName":"C","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"],"display":"typeof C"}, -{"id":92,"symbolName":"C","recursionId":85,"instantiatedType":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, -{"id":93,"symbolName":"C","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, -{"id":94,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":95,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":96,"symbolName":"__type","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":18},"end":{"line":3,"character":26}},"flags":["Object"],"display":"{ a: 1; }"}, -{"id":97,"symbolName":"__type","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":16},"end":{"line":4,"character":25}},"flags":["Object"],"display":"{ p1: 1; }"}, -{"id":98,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":16},"end":{"line":5,"character":25}},"flags":["Object"],"display":"{ p2: 2; }"}, -{"id":99,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":16},"end":{"line":6,"character":25}},"flags":["Object"],"display":"{ p3: 3; }"}, -{"id":100,"symbolName":"__type","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":16},"end":{"line":7,"character":25}},"flags":["Object"],"display":"{ p4: 4; }"}, -{"id":101,"symbolName":"__type","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":16},"end":{"line":8,"character":25}},"flags":["Object"],"display":"{ p5: 5; }"}, -{"id":102,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":16},"end":{"line":9,"character":25}},"flags":["Object"],"display":"{ p6: 6; }"}, -{"id":103,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":16},"end":{"line":10,"character":25}},"flags":["Object"],"display":"{ p7: 7; }"}, -{"id":104,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":16},"end":{"line":11,"character":25}},"flags":["Object"],"display":"{ p8: 8; }"}, -{"id":105,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":16},"end":{"line":12,"character":25}},"flags":["Object"],"display":"{ p9: 9; }"}, -{"id":106,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":17},"end":{"line":13,"character":28}},"flags":["Object"],"display":"{ p10: 10; }"}, -{"id":107,"recursionId":97,"flags":["NumberLiteral"],"display":"10"}, -{"id":108,"recursionId":98,"flags":["NumberLiteral"],"display":"10"}, -{"id":109,"recursionId":99,"flags":["NumberLiteral"],"display":"9"}, -{"id":110,"recursionId":100,"flags":["NumberLiteral"],"display":"9"}, -{"id":111,"recursionId":101,"flags":["NumberLiteral"],"display":"8"}, -{"id":112,"recursionId":102,"flags":["NumberLiteral"],"display":"8"}, -{"id":113,"recursionId":103,"flags":["NumberLiteral"],"display":"7"}, -{"id":114,"recursionId":104,"flags":["NumberLiteral"],"display":"7"}, -{"id":115,"recursionId":105,"flags":["NumberLiteral"],"display":"6"}, -{"id":116,"recursionId":106,"flags":["NumberLiteral"],"display":"6"}, -{"id":117,"recursionId":107,"flags":["NumberLiteral"],"display":"5"}, -{"id":118,"recursionId":108,"flags":["NumberLiteral"],"display":"5"}, -{"id":119,"recursionId":109,"flags":["NumberLiteral"],"display":"4"}, -{"id":120,"recursionId":110,"flags":["NumberLiteral"],"display":"4"}, -{"id":121,"recursionId":111,"flags":["NumberLiteral"],"display":"3"}, -{"id":122,"recursionId":112,"flags":["NumberLiteral"],"display":"3"}, -{"id":123,"recursionId":113,"flags":["NumberLiteral"],"display":"2"}, -{"id":124,"recursionId":114,"flags":["NumberLiteral"],"display":"2"}, -{"id":125,"recursionId":115,"flags":["NumberLiteral"],"display":"1"}, -{"id":126,"recursionId":116,"flags":["NumberLiteral"],"display":"1"}, -{"id":127,"recursionId":117,"flags":["StringLiteral"],"display":"\"m1\""}, -{"id":128,"recursionId":118,"flags":["StringLiteral"],"display":"\"m2\""}, -{"id":129,"recursionId":119,"flags":["StringLiteral"],"display":"\"m3\""}, -{"id":130,"recursionId":120,"flags":["StringLiteral"],"display":"\"m4\""}, -{"id":131,"recursionId":121,"flags":["StringLiteral"],"display":"\"m5\""}, -{"id":132,"recursionId":122,"flags":["StringLiteral"],"display":"\"m6\""}, -{"id":133,"recursionId":123,"flags":["StringLiteral"],"display":"\"m7\""}, -{"id":134,"recursionId":124,"flags":["StringLiteral"],"display":"\"m8\""}, -{"id":135,"recursionId":125,"flags":["StringLiteral"],"display":"\"m9\""}, -{"id":136,"recursionId":126,"flags":["StringLiteral"],"display":"\"m10\""}, -{"id":137,"recursionId":127,"flags":["StringLiteral"],"display":"\"prototype\""}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"X","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, +{"id":83,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":84,"recursionId":83,"keyofType":82,"flags":["Index"]}, +{"id":85,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":86,"recursionId":81,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, +{"id":87,"symbolName":"Symbol","recursionId":85,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":88,"symbolName":"SymbolConstructor","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":89,"symbolName":"toStringTag","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":90,"symbolName":"expand","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, +{"id":91,"symbolName":"C","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"],"display":"typeof C"}, +{"id":92,"symbolName":"C","recursionId":90,"instantiatedType":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, +{"id":93,"symbolName":"C","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, +{"id":94,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":95,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":96,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":18},"end":{"line":3,"character":26}},"flags":["Object"],"display":"{ a: 1; }"}, +{"id":97,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":16},"end":{"line":4,"character":25}},"flags":["Object"],"display":"{ p1: 1; }"}, +{"id":98,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":16},"end":{"line":5,"character":25}},"flags":["Object"],"display":"{ p2: 2; }"}, +{"id":99,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":16},"end":{"line":6,"character":25}},"flags":["Object"],"display":"{ p3: 3; }"}, +{"id":100,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":16},"end":{"line":7,"character":25}},"flags":["Object"],"display":"{ p4: 4; }"}, +{"id":101,"symbolName":"__type","recursionId":97,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":16},"end":{"line":8,"character":25}},"flags":["Object"],"display":"{ p5: 5; }"}, +{"id":102,"symbolName":"__type","recursionId":98,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":16},"end":{"line":9,"character":25}},"flags":["Object"],"display":"{ p6: 6; }"}, +{"id":103,"symbolName":"__type","recursionId":99,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":16},"end":{"line":10,"character":25}},"flags":["Object"],"display":"{ p7: 7; }"}, +{"id":104,"symbolName":"__type","recursionId":100,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":16},"end":{"line":11,"character":25}},"flags":["Object"],"display":"{ p8: 8; }"}, +{"id":105,"symbolName":"__type","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":16},"end":{"line":12,"character":25}},"flags":["Object"],"display":"{ p9: 9; }"}, +{"id":106,"symbolName":"__type","recursionId":102,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":17},"end":{"line":13,"character":28}},"flags":["Object"],"display":"{ p10: 10; }"}, +{"id":107,"recursionId":103,"flags":["NumberLiteral"],"display":"10"}, +{"id":108,"recursionId":104,"flags":["NumberLiteral"],"display":"10"}, +{"id":109,"recursionId":105,"flags":["NumberLiteral"],"display":"9"}, +{"id":110,"recursionId":106,"flags":["NumberLiteral"],"display":"9"}, +{"id":111,"recursionId":107,"flags":["NumberLiteral"],"display":"8"}, +{"id":112,"recursionId":108,"flags":["NumberLiteral"],"display":"8"}, +{"id":113,"recursionId":109,"flags":["NumberLiteral"],"display":"7"}, +{"id":114,"recursionId":110,"flags":["NumberLiteral"],"display":"7"}, +{"id":115,"recursionId":111,"flags":["NumberLiteral"],"display":"6"}, +{"id":116,"recursionId":112,"flags":["NumberLiteral"],"display":"6"}, +{"id":117,"recursionId":113,"flags":["NumberLiteral"],"display":"5"}, +{"id":118,"recursionId":114,"flags":["NumberLiteral"],"display":"5"}, +{"id":119,"recursionId":115,"flags":["NumberLiteral"],"display":"4"}, +{"id":120,"recursionId":116,"flags":["NumberLiteral"],"display":"4"}, +{"id":121,"recursionId":117,"flags":["NumberLiteral"],"display":"3"}, +{"id":122,"recursionId":118,"flags":["NumberLiteral"],"display":"3"}, +{"id":123,"recursionId":119,"flags":["NumberLiteral"],"display":"2"}, +{"id":124,"recursionId":120,"flags":["NumberLiteral"],"display":"2"}, +{"id":125,"recursionId":121,"flags":["NumberLiteral"],"display":"1"}, +{"id":126,"recursionId":122,"flags":["NumberLiteral"],"display":"1"}, +{"id":127,"recursionId":123,"flags":["StringLiteral"],"display":"\"m1\""}, +{"id":128,"recursionId":124,"flags":["StringLiteral"],"display":"\"m2\""}, +{"id":129,"recursionId":125,"flags":["StringLiteral"],"display":"\"m3\""}, +{"id":130,"recursionId":126,"flags":["StringLiteral"],"display":"\"m4\""}, +{"id":131,"recursionId":127,"flags":["StringLiteral"],"display":"\"m5\""}, +{"id":132,"recursionId":128,"flags":["StringLiteral"],"display":"\"m6\""}, +{"id":133,"recursionId":129,"flags":["StringLiteral"],"display":"\"m7\""}, +{"id":134,"recursionId":130,"flags":["StringLiteral"],"display":"\"m8\""}, +{"id":135,"recursionId":131,"flags":["StringLiteral"],"display":"\"m9\""}, +{"id":136,"recursionId":132,"flags":["StringLiteral"],"display":"\"m10\""}, +{"id":137,"recursionId":133,"flags":["StringLiteral"],"display":"\"prototype\""}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js index 98f600aca3a1c..620aa56b804f8 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js @@ -445,113 +445,113 @@ export declare const widget: import("./gadget").Gadget; {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"\"/home/src/workspaces/project/parts/index\"","recursionId":76,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/index.d.ts","start":{"line":1,"character":1},"end":{"line":14,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/index\")"}, -{"id":83,"symbolName":"\"/home/src/workspaces/project/parts/alpha\"","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/alpha.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/alpha\")"}, -{"id":84,"symbolName":"\"/home/src/workspaces/project/parts/beta\"","recursionId":78,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/beta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/beta\")"}, -{"id":85,"symbolName":"\"/home/src/workspaces/project/parts/gamma\"","recursionId":79,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/gamma.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/gamma\")"}, -{"id":86,"symbolName":"\"/home/src/workspaces/project/parts/delta\"","recursionId":80,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/delta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/delta\")"}, -{"id":87,"symbolName":"\"/home/src/workspaces/project/parts/epsilon\"","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/epsilon.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/epsilon\")"}, -{"id":88,"symbolName":"\"/home/src/workspaces/project/parts/zeta\"","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/zeta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/zeta\")"}, -{"id":89,"symbolName":"\"/home/src/workspaces/project/parts/eta\"","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/eta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/eta\")"}, -{"id":90,"symbolName":"\"/home/src/workspaces/project/parts/theta\"","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/theta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/theta\")"}, -{"id":91,"symbolName":"\"/home/src/workspaces/project/parts/iota\"","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/iota.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/iota\")"}, -{"id":92,"symbolName":"\"/home/src/workspaces/project/parts/kappa\"","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/kappa.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/kappa\")"}, -{"id":93,"symbolName":"\"/home/src/workspaces/project/parts/lambda\"","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/lambda.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/lambda\")"}, -{"id":94,"symbolName":"\"/home/src/workspaces/project/parts/mu\"","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/mu.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/mu\")"}, -{"id":95,"recursionId":89,"flags":["NumberLiteral"],"display":"1"}, -{"id":96,"recursionId":90,"flags":["NumberLiteral"],"display":"1"}, -{"id":97,"recursionId":91,"flags":["NumberLiteral"],"display":"2"}, -{"id":98,"recursionId":92,"flags":["NumberLiteral"],"display":"2"}, -{"id":99,"recursionId":93,"flags":["NumberLiteral"],"display":"3"}, -{"id":100,"recursionId":94,"flags":["NumberLiteral"],"display":"3"}, -{"id":101,"recursionId":95,"flags":["NumberLiteral"],"display":"4"}, -{"id":102,"recursionId":96,"flags":["NumberLiteral"],"display":"4"}, -{"id":103,"recursionId":97,"flags":["NumberLiteral"],"display":"5"}, -{"id":104,"recursionId":98,"flags":["NumberLiteral"],"display":"5"}, -{"id":105,"recursionId":99,"flags":["NumberLiteral"],"display":"6"}, -{"id":106,"recursionId":100,"flags":["NumberLiteral"],"display":"6"}, -{"id":107,"recursionId":101,"flags":["NumberLiteral"],"display":"7"}, -{"id":108,"recursionId":102,"flags":["NumberLiteral"],"display":"7"}, -{"id":109,"recursionId":103,"flags":["NumberLiteral"],"display":"8"}, -{"id":110,"recursionId":104,"flags":["NumberLiteral"],"display":"8"}, -{"id":111,"recursionId":105,"flags":["NumberLiteral"],"display":"9"}, -{"id":112,"recursionId":106,"flags":["NumberLiteral"],"display":"9"}, -{"id":113,"recursionId":107,"flags":["NumberLiteral"],"display":"10"}, -{"id":114,"recursionId":108,"flags":["NumberLiteral"],"display":"10"}, -{"id":115,"recursionId":109,"flags":["NumberLiteral"],"display":"11"}, -{"id":116,"recursionId":110,"flags":["NumberLiteral"],"display":"11"}, -{"id":117,"recursionId":111,"flags":["NumberLiteral"],"display":"12"}, -{"id":118,"recursionId":112,"flags":["NumberLiteral"],"display":"12"}, -{"id":119,"symbolName":"__type","recursionId":113,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":5,"character":29},"end":{"line":5,"character":106}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, -{"id":120,"symbolName":"T","recursionId":114,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, -{"id":121,"symbolName":"T","recursionId":114,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, -{"id":122,"symbolName":"__type","recursionId":115,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: A; b: B; c: C; d: D; e: E; f: F; g: G; h: H; i: I; j: J; k: K; l: L; }"}, -{"id":123,"symbolName":"A","recursionId":116,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":46},"end":{"line":1,"character":47}},"flags":["TypeParameter"]}, -{"id":124,"symbolName":"B","recursionId":117,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":58},"end":{"line":1,"character":59}},"flags":["TypeParameter"]}, -{"id":125,"symbolName":"C","recursionId":118,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":70},"end":{"line":1,"character":71}},"flags":["TypeParameter"]}, -{"id":126,"symbolName":"D","recursionId":119,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":82},"end":{"line":1,"character":83}},"flags":["TypeParameter"]}, -{"id":127,"symbolName":"E","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":94},"end":{"line":1,"character":95}},"flags":["TypeParameter"]}, -{"id":128,"symbolName":"F","recursionId":121,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":106},"end":{"line":1,"character":107}},"flags":["TypeParameter"]}, -{"id":129,"symbolName":"G","recursionId":122,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":118},"end":{"line":1,"character":119}},"flags":["TypeParameter"]}, -{"id":130,"symbolName":"H","recursionId":123,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":130},"end":{"line":1,"character":131}},"flags":["TypeParameter"]}, -{"id":131,"symbolName":"I","recursionId":124,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":142},"end":{"line":1,"character":143}},"flags":["TypeParameter"]}, -{"id":132,"symbolName":"J","recursionId":125,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":154},"end":{"line":1,"character":155}},"flags":["TypeParameter"]}, -{"id":133,"symbolName":"K","recursionId":126,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":166},"end":{"line":1,"character":167}},"flags":["TypeParameter"]}, -{"id":134,"symbolName":"L","recursionId":127,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":178},"end":{"line":1,"character":179}},"flags":["TypeParameter"]}, -{"id":135,"symbolName":"__type","recursionId":115,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: unknown; b: unknown; c: unknown; d: unknown; e: unknown; f: unknown; g: unknown; h: unknown; i: unknown; j: unknown; k: unknown; l: unknown; }"}, -{"id":136,"symbolName":"Fields","recursionId":128,"aliasTypeArguments":[120],"conditionalCheckType":121,"conditionalExtendsType":122,"conditionalTrueType":-1,"conditionalFalseType":-1,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":1},"end":{"line":1,"character":229}},"flags":["Conditional"]}, -{"id":137,"symbolName":"__type","recursionId":115,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, -{"id":138,"recursionId":129,"flags":["TypeParameter"]}, -{"id":139,"recursionId":130,"flags":["TypeParameter"]}, -{"id":140,"recursionId":131,"flags":["TypeParameter"]}, -{"id":141,"recursionId":132,"flags":["TypeParameter"]}, -{"id":142,"recursionId":133,"flags":["TypeParameter"]}, -{"id":143,"recursionId":134,"flags":["TypeParameter"]}, -{"id":144,"recursionId":135,"flags":["TypeParameter"]}, -{"id":145,"recursionId":136,"flags":["TypeParameter"]}, -{"id":146,"recursionId":137,"flags":["TypeParameter"]}, -{"id":147,"recursionId":138,"flags":["TypeParameter"]}, -{"id":148,"recursionId":139,"flags":["TypeParameter"]}, -{"id":149,"recursionId":140,"flags":["TypeParameter"]}, -{"id":150,"recursionId":141,"isTuple":true,"instantiatedType":150,"typeArguments":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Object"]}, -{"id":151,"recursionId":142,"flags":["TypeParameter"]}, -{"id":152,"recursionId":143,"instantiatedType":150,"typeArguments":[123,124,125,126,127,128,129,130,131,132,133,134],"flags":["Object"]}, -{"id":153,"recursionId":141,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, -{"id":154,"recursionId":144,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, -{"id":155,"recursionId":145,"unionTypes":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Union"],"display":"? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ?"}, -{"id":156,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[155],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":157,"recursionId":146,"unionTypes":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Union"],"display":"1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12"}, -{"id":158,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[157],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":159,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[157,153],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":160,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[157,154],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":161,"symbolName":"makeWidget","recursionId":147,"firstDeclaration":{"path":"/home/src/workspaces/project/widget.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":46}},"flags":["Object"],"display":"() => Gadget"}, -{"id":162,"symbolName":"Gadget","recursionId":148,"firstDeclaration":{"path":"/home/src/workspaces/project/gadget.d.ts","start":{"line":1,"character":1},"end":{"line":3,"character":2}},"flags":["Object"]}, -{"id":163,"symbolName":"__type","recursionId":149,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ar.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ar\"; }"}, -{"id":164,"symbolName":"__type","recursionId":150,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/de.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"de\"; }"}, -{"id":165,"symbolName":"__type","recursionId":151,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/en.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"en\"; }"}, -{"id":166,"symbolName":"__type","recursionId":152,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/es.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"es\"; }"}, -{"id":167,"symbolName":"__type","recursionId":153,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/fr.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"fr\"; }"}, -{"id":168,"symbolName":"__type","recursionId":154,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/he.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"he\"; }"}, -{"id":169,"symbolName":"__type","recursionId":155,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/it.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"it\"; }"}, -{"id":170,"symbolName":"__type","recursionId":156,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ja.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ja\"; }"}, -{"id":171,"symbolName":"__type","recursionId":157,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ko.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ko\"; }"}, -{"id":172,"symbolName":"__type","recursionId":158,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/nl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"nl\"; }"}, -{"id":173,"symbolName":"__type","recursionId":159,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pl\"; }"}, -{"id":174,"symbolName":"__type","recursionId":160,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pt.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pt\"; }"}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"\"/home/src/workspaces/project/parts/index\"","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/index.d.ts","start":{"line":1,"character":1},"end":{"line":14,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/index\")"}, +{"id":83,"symbolName":"\"/home/src/workspaces/project/parts/alpha\"","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/alpha.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/alpha\")"}, +{"id":84,"symbolName":"\"/home/src/workspaces/project/parts/beta\"","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/beta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/beta\")"}, +{"id":85,"symbolName":"\"/home/src/workspaces/project/parts/gamma\"","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/gamma.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/gamma\")"}, +{"id":86,"symbolName":"\"/home/src/workspaces/project/parts/delta\"","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/delta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/delta\")"}, +{"id":87,"symbolName":"\"/home/src/workspaces/project/parts/epsilon\"","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/epsilon.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/epsilon\")"}, +{"id":88,"symbolName":"\"/home/src/workspaces/project/parts/zeta\"","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/zeta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/zeta\")"}, +{"id":89,"symbolName":"\"/home/src/workspaces/project/parts/eta\"","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/eta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/eta\")"}, +{"id":90,"symbolName":"\"/home/src/workspaces/project/parts/theta\"","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/theta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/theta\")"}, +{"id":91,"symbolName":"\"/home/src/workspaces/project/parts/iota\"","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/iota.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/iota\")"}, +{"id":92,"symbolName":"\"/home/src/workspaces/project/parts/kappa\"","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/kappa.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/kappa\")"}, +{"id":93,"symbolName":"\"/home/src/workspaces/project/parts/lambda\"","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/lambda.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/lambda\")"}, +{"id":94,"symbolName":"\"/home/src/workspaces/project/parts/mu\"","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/mu.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/mu\")"}, +{"id":95,"recursionId":94,"flags":["NumberLiteral"],"display":"1"}, +{"id":96,"recursionId":95,"flags":["NumberLiteral"],"display":"1"}, +{"id":97,"recursionId":96,"flags":["NumberLiteral"],"display":"2"}, +{"id":98,"recursionId":97,"flags":["NumberLiteral"],"display":"2"}, +{"id":99,"recursionId":98,"flags":["NumberLiteral"],"display":"3"}, +{"id":100,"recursionId":99,"flags":["NumberLiteral"],"display":"3"}, +{"id":101,"recursionId":100,"flags":["NumberLiteral"],"display":"4"}, +{"id":102,"recursionId":101,"flags":["NumberLiteral"],"display":"4"}, +{"id":103,"recursionId":102,"flags":["NumberLiteral"],"display":"5"}, +{"id":104,"recursionId":103,"flags":["NumberLiteral"],"display":"5"}, +{"id":105,"recursionId":104,"flags":["NumberLiteral"],"display":"6"}, +{"id":106,"recursionId":105,"flags":["NumberLiteral"],"display":"6"}, +{"id":107,"recursionId":106,"flags":["NumberLiteral"],"display":"7"}, +{"id":108,"recursionId":107,"flags":["NumberLiteral"],"display":"7"}, +{"id":109,"recursionId":108,"flags":["NumberLiteral"],"display":"8"}, +{"id":110,"recursionId":109,"flags":["NumberLiteral"],"display":"8"}, +{"id":111,"recursionId":110,"flags":["NumberLiteral"],"display":"9"}, +{"id":112,"recursionId":111,"flags":["NumberLiteral"],"display":"9"}, +{"id":113,"recursionId":112,"flags":["NumberLiteral"],"display":"10"}, +{"id":114,"recursionId":113,"flags":["NumberLiteral"],"display":"10"}, +{"id":115,"recursionId":114,"flags":["NumberLiteral"],"display":"11"}, +{"id":116,"recursionId":115,"flags":["NumberLiteral"],"display":"11"}, +{"id":117,"recursionId":116,"flags":["NumberLiteral"],"display":"12"}, +{"id":118,"recursionId":117,"flags":["NumberLiteral"],"display":"12"}, +{"id":119,"symbolName":"__type","recursionId":118,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":5,"character":29},"end":{"line":5,"character":106}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, +{"id":120,"symbolName":"T","recursionId":119,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, +{"id":121,"symbolName":"T","recursionId":119,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, +{"id":122,"symbolName":"__type","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: A; b: B; c: C; d: D; e: E; f: F; g: G; h: H; i: I; j: J; k: K; l: L; }"}, +{"id":123,"symbolName":"A","recursionId":121,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":46},"end":{"line":1,"character":47}},"flags":["TypeParameter"]}, +{"id":124,"symbolName":"B","recursionId":122,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":58},"end":{"line":1,"character":59}},"flags":["TypeParameter"]}, +{"id":125,"symbolName":"C","recursionId":123,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":70},"end":{"line":1,"character":71}},"flags":["TypeParameter"]}, +{"id":126,"symbolName":"D","recursionId":124,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":82},"end":{"line":1,"character":83}},"flags":["TypeParameter"]}, +{"id":127,"symbolName":"E","recursionId":125,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":94},"end":{"line":1,"character":95}},"flags":["TypeParameter"]}, +{"id":128,"symbolName":"F","recursionId":126,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":106},"end":{"line":1,"character":107}},"flags":["TypeParameter"]}, +{"id":129,"symbolName":"G","recursionId":127,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":118},"end":{"line":1,"character":119}},"flags":["TypeParameter"]}, +{"id":130,"symbolName":"H","recursionId":128,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":130},"end":{"line":1,"character":131}},"flags":["TypeParameter"]}, +{"id":131,"symbolName":"I","recursionId":129,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":142},"end":{"line":1,"character":143}},"flags":["TypeParameter"]}, +{"id":132,"symbolName":"J","recursionId":130,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":154},"end":{"line":1,"character":155}},"flags":["TypeParameter"]}, +{"id":133,"symbolName":"K","recursionId":131,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":166},"end":{"line":1,"character":167}},"flags":["TypeParameter"]}, +{"id":134,"symbolName":"L","recursionId":132,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":178},"end":{"line":1,"character":179}},"flags":["TypeParameter"]}, +{"id":135,"symbolName":"__type","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: unknown; b: unknown; c: unknown; d: unknown; e: unknown; f: unknown; g: unknown; h: unknown; i: unknown; j: unknown; k: unknown; l: unknown; }"}, +{"id":136,"symbolName":"Fields","recursionId":133,"aliasTypeArguments":[120],"conditionalCheckType":121,"conditionalExtendsType":122,"conditionalTrueType":-1,"conditionalFalseType":-1,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":1},"end":{"line":1,"character":229}},"flags":["Conditional"]}, +{"id":137,"symbolName":"__type","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, +{"id":138,"recursionId":134,"flags":["TypeParameter"]}, +{"id":139,"recursionId":135,"flags":["TypeParameter"]}, +{"id":140,"recursionId":136,"flags":["TypeParameter"]}, +{"id":141,"recursionId":137,"flags":["TypeParameter"]}, +{"id":142,"recursionId":138,"flags":["TypeParameter"]}, +{"id":143,"recursionId":139,"flags":["TypeParameter"]}, +{"id":144,"recursionId":140,"flags":["TypeParameter"]}, +{"id":145,"recursionId":141,"flags":["TypeParameter"]}, +{"id":146,"recursionId":142,"flags":["TypeParameter"]}, +{"id":147,"recursionId":143,"flags":["TypeParameter"]}, +{"id":148,"recursionId":144,"flags":["TypeParameter"]}, +{"id":149,"recursionId":145,"flags":["TypeParameter"]}, +{"id":150,"recursionId":146,"isTuple":true,"instantiatedType":150,"typeArguments":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Object"]}, +{"id":151,"recursionId":147,"flags":["TypeParameter"]}, +{"id":152,"recursionId":148,"instantiatedType":150,"typeArguments":[123,124,125,126,127,128,129,130,131,132,133,134],"flags":["Object"]}, +{"id":153,"recursionId":149,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, +{"id":154,"recursionId":150,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, +{"id":155,"recursionId":151,"unionTypes":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Union"],"display":"? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ?"}, +{"id":156,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[155],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":157,"recursionId":152,"unionTypes":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Union"],"display":"1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12"}, +{"id":158,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[157],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":159,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[157,153],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":160,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[157,154],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":161,"symbolName":"makeWidget","recursionId":153,"firstDeclaration":{"path":"/home/src/workspaces/project/widget.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":46}},"flags":["Object"],"display":"() => Gadget"}, +{"id":162,"symbolName":"Gadget","recursionId":154,"firstDeclaration":{"path":"/home/src/workspaces/project/gadget.d.ts","start":{"line":1,"character":1},"end":{"line":3,"character":2}},"flags":["Object"]}, +{"id":163,"symbolName":"__type","recursionId":155,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ar.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ar\"; }"}, +{"id":164,"symbolName":"__type","recursionId":156,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/de.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"de\"; }"}, +{"id":165,"symbolName":"__type","recursionId":157,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/en.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"en\"; }"}, +{"id":166,"symbolName":"__type","recursionId":158,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/es.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"es\"; }"}, +{"id":167,"symbolName":"__type","recursionId":159,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/fr.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"fr\"; }"}, +{"id":168,"symbolName":"__type","recursionId":160,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/he.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"he\"; }"}, +{"id":169,"symbolName":"__type","recursionId":161,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/it.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"it\"; }"}, +{"id":170,"symbolName":"__type","recursionId":162,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ja.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ja\"; }"}, +{"id":171,"symbolName":"__type","recursionId":163,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ko.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ko\"; }"}, +{"id":172,"symbolName":"__type","recursionId":164,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/nl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"nl\"; }"}, +{"id":173,"symbolName":"__type","recursionId":165,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pl\"; }"}, +{"id":174,"symbolName":"__type","recursionId":166,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pt.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pt\"; }"}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js index e4f896a874835..470095da1544d 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js @@ -147,34 +147,34 @@ declare const console: { log(msg: any): void; }; {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":83,"recursionId":76,"flags":["StringLiteral"],"display":"\"length\""}, -{"id":84,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":85,"symbolName":"SymbolConstructor","recursionId":77,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":86,"recursionId":78,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, -{"id":87,"symbolName":"toStringTag","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":88,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":89,"symbolName":"__type","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, -{"id":90,"symbolName":"Person","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":91,"recursionId":83,"flags":["StringLiteral"],"display":"\"Alice\""}, -{"id":92,"recursionId":84,"flags":["StringLiteral"],"display":"\"Alice\""}, -{"id":93,"recursionId":85,"flags":["NumberLiteral"],"display":"30"}, -{"id":94,"recursionId":86,"flags":["NumberLiteral"],"display":"30"}, -{"id":95,"symbolName":"__object","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":5,"character":19},"end":{"line":5,"character":45}},"flags":["Object"],"display":"{ name: string; age: number; }"}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"Array","recursionId":81,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":83,"recursionId":82,"flags":["StringLiteral"],"display":"\"length\""}, +{"id":84,"symbolName":"ReadonlyArray","recursionId":83,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":85,"symbolName":"SymbolConstructor","recursionId":84,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":86,"recursionId":85,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, +{"id":87,"symbolName":"toStringTag","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":88,"symbolName":"Symbol","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":89,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, +{"id":90,"symbolName":"Person","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":91,"recursionId":90,"flags":["StringLiteral"],"display":"\"Alice\""}, +{"id":92,"recursionId":91,"flags":["StringLiteral"],"display":"\"Alice\""}, +{"id":93,"recursionId":92,"flags":["NumberLiteral"],"display":"30"}, +{"id":94,"recursionId":93,"flags":["NumberLiteral"],"display":"30"}, +{"id":95,"symbolName":"__object","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":5,"character":19},"end":{"line":5,"character":45}},"flags":["Object"],"display":"{ name: string; age: number; }"}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js index 5d958c51b03c7..bb92b7489685e 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js @@ -174,61 +174,60 @@ declare const console: { log(msg: any): void; }; {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":83,"recursionId":76,"flags":["StringLiteral"],"display":"\"length\""}, -{"id":84,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":85,"symbolName":"SymbolConstructor","recursionId":77,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":86,"recursionId":78,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, -{"id":87,"symbolName":"toStringTag","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":88,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":89,"symbolName":"__type","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, -{"id":90,"symbolName":"T","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":28},"end":{"line":1,"character":29}},"flags":["TypeParameter"]}, -{"id":91,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[90],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":92,"symbolName":"Container","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["TypeParameter"]}, -{"id":93,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[90,92],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":94,"symbolName":"U","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, -{"id":95,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: T) => U"}, -{"id":96,"symbolName":"Container","recursionId":86,"instantiatedType":91,"typeArguments":[94],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":97,"symbolName":"T","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":22},"end":{"line":5,"character":23}},"flags":["TypeParameter"]}, -{"id":98,"symbolName":"Nullable","recursionId":88,"unionTypes":[10,13,97],"aliasTypeArguments":[97],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, -{"id":99,"symbolName":"Container","recursionId":89,"instantiatedType":91,"typeArguments":[15],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":100,"recursionId":90,"flags":["NumberLiteral"],"display":"42"}, -{"id":101,"recursionId":91,"flags":["NumberLiteral"],"display":"42"}, -{"id":102,"symbolName":"map","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: T) => U) => Container"}, -{"id":103,"symbolName":"map","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: number) => U) => Container"}, -{"id":104,"symbolName":"U","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, -{"id":105,"symbolName":"__function","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":48},"end":{"line":2,"character":87}},"flags":["Object"],"display":"(fn: (x: number) => U) => { value: U; map: (fn: (x: number) => U) => Container; }"}, -{"id":106,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: number) => U"}, -{"id":107,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[104],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":108,"symbolName":"map","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: U) => U) => Container"}, -{"id":109,"symbolName":"__object","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":57},"end":{"line":2,"character":86}},"flags":["Object"],"display":"{ value: U; map: (fn: (x: number) => U) => Container; }"}, -{"id":110,"symbolName":"__object","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":57},"end":{"line":2,"character":86}},"flags":["Object"],"display":"{ value: U; map: (fn: (x: number) => U) => Container; }"}, -{"id":111,"symbolName":"__object","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":30},"end":{"line":2,"character":89}},"flags":["Object"],"display":"{ value: number; map: (fn: (x: number) => U) => { value: U; map: (fn: (x: number) => U) => Container; }; }"}, -{"id":112,"symbolName":"U","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, -{"id":113,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: number) => any"}, -{"id":114,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => any"}, -{"id":115,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => U"}, -{"id":116,"recursionId":97,"flags":["StringLiteral"],"display":"\"value\""}, -{"id":117,"recursionId":98,"flags":["StringLiteral"],"display":"\"map\""}, -{"id":118,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[112],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":119,"symbolName":"Nullable","recursionId":99,"unionTypes":[10,13,14],"aliasTypeArguments":[14],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, -{"id":120,"recursionId":100,"flags":["StringLiteral"],"display":"\"hello\""}, -{"id":121,"recursionId":101,"flags":["StringLiteral"],"display":"\"hello\""}, -{"id":122,"symbolName":"__object","recursionId":102,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":57},"end":{"line":2,"character":86}},"flags":["Object"],"display":"{ value: U; map: (fn: (x: number) => U) => Container; }"}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"Array","recursionId":81,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":83,"recursionId":82,"flags":["StringLiteral"],"display":"\"length\""}, +{"id":84,"symbolName":"ReadonlyArray","recursionId":83,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":85,"symbolName":"SymbolConstructor","recursionId":84,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":86,"recursionId":85,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, +{"id":87,"symbolName":"toStringTag","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":88,"symbolName":"Symbol","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":89,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, +{"id":90,"symbolName":"T","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":28},"end":{"line":1,"character":29}},"flags":["TypeParameter"]}, +{"id":91,"symbolName":"Container","recursionId":90,"instantiatedType":91,"typeArguments":[90],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":92,"symbolName":"Container","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["TypeParameter"]}, +{"id":93,"symbolName":"Container","recursionId":92,"instantiatedType":91,"typeArguments":[90,92],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":94,"symbolName":"U","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, +{"id":95,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: T) => U"}, +{"id":96,"symbolName":"Container","recursionId":95,"instantiatedType":91,"typeArguments":[94],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":97,"symbolName":"T","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":22},"end":{"line":5,"character":23}},"flags":["TypeParameter"]}, +{"id":98,"symbolName":"Nullable","recursionId":97,"unionTypes":[10,13,97],"aliasTypeArguments":[97],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, +{"id":99,"symbolName":"Container","recursionId":98,"instantiatedType":91,"typeArguments":[15],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":100,"recursionId":99,"flags":["NumberLiteral"],"display":"42"}, +{"id":101,"recursionId":100,"flags":["NumberLiteral"],"display":"42"}, +{"id":102,"symbolName":"map","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: T) => U) => Container"}, +{"id":103,"symbolName":"map","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: number) => U) => Container"}, +{"id":104,"symbolName":"U","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, +{"id":105,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: number) => U"}, +{"id":106,"symbolName":"Container","recursionId":102,"instantiatedType":91,"typeArguments":[104],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":107,"symbolName":"map","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: U) => U) => Container"}, +{"id":108,"symbolName":"__object","recursionId":103,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":57},"end":{"line":2,"character":86}},"flags":["Object"],"display":"{ value: U; map: (fn: (x: number) => U) => Container; }"}, +{"id":109,"symbolName":"__object","recursionId":104,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":57},"end":{"line":2,"character":86}},"flags":["Object"],"display":"{ value: U; map: (fn: (x: number) => U) => Container; }"}, +{"id":110,"symbolName":"__function","recursionId":105,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":48},"end":{"line":2,"character":87}},"flags":["Object"],"display":"(fn: (x: number) => U) => { value: U; map: (fn: (x: number) => U) => Container; }"}, +{"id":111,"symbolName":"__object","recursionId":106,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":30},"end":{"line":2,"character":89}},"flags":["Object"],"display":"{ value: number; map: (fn: (x: number) => U) => { value: U; map: (fn: (x: number) => U) => Container; }; }"}, +{"id":112,"symbolName":"U","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, +{"id":113,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: number) => any"}, +{"id":114,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => U"}, +{"id":115,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => any"}, +{"id":116,"recursionId":107,"flags":["StringLiteral"],"display":"\"value\""}, +{"id":117,"recursionId":108,"flags":["StringLiteral"],"display":"\"map\""}, +{"id":118,"symbolName":"Container","recursionId":109,"instantiatedType":91,"typeArguments":[112],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":119,"symbolName":"Nullable","recursionId":110,"unionTypes":[10,13,14],"aliasTypeArguments":[14],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, +{"id":120,"recursionId":111,"flags":["StringLiteral"],"display":"\"hello\""}, +{"id":121,"recursionId":112,"flags":["StringLiteral"],"display":"\"hello\""}] diff --git a/tsc/testdata/baselines/reference/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js b/tsc/testdata/baselines/reference/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js index ede9c55f1530e..47afd6e8c58c4 100644 --- a/tsc/testdata/baselines/reference/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js +++ b/tsc/testdata/baselines/reference/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js @@ -191,10 +191,14 @@ export function* values() { yield 1; } tsc -ExitStatus:: Success +ExitStatus:: DiagnosticsPresent_OutputsGenerated Output:: +error TS2318: Cannot find global type 'IterableIterator'. + +Found 1 error. + //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"semanticDiagnosticsPerFile":[[2,[{"noFile":true,"code":2318,"category":1,"messageKey":"Cannot_find_global_type_0_2318","messageArgs":["IterableIterator"]}]]],"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", @@ -236,6 +240,22 @@ Output:: } } ], + "semanticDiagnosticsPerFile": [ + [ + "./repro.ts", + [ + { + "noFile": true, + "code": 2318, + "category": 1, + "messageKey": "Cannot_find_global_type_0_2318", + "messageArgs": [ + "IterableIterator" + ] + } + ] + ] + ], "affectedFilesPendingEmit": [ [ "./repro.ts", @@ -243,7 +263,7 @@ Output:: 2 ] ], - "size": 1136 + "size": 1295 } tsconfig.json:: @@ -253,22 +273,17 @@ Signatures:: (computed .d.ts) /home/src/workspaces/project/repro.ts -Diff:: Like Strada, signature generation produces the missing-global diagnostic before semantic checking, so it is excluded from the file's semantic diagnostics. ---- nonIncremental.output.txt -+++ incremental.output.txt -@@ -1,4 +0,0 @@ --error TS2318: Cannot find global type 'IterableIterator'. -- --Found 1 error. -- - Edit [2]:: no change tsc -ExitStatus:: Success +ExitStatus:: DiagnosticsPresent_OutputsGenerated Output:: +error TS2318: Cannot find global type 'IterableIterator'. + +Found 1 error. + //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"semanticDiagnosticsPerFile":[[2,[{"noFile":true,"code":2318,"category":1,"messageKey":"Cannot_find_global_type_0_2318","messageArgs":["IterableIterator"]}]]],"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", @@ -309,6 +324,22 @@ Output:: } } ], + "semanticDiagnosticsPerFile": [ + [ + "./repro.ts", + [ + { + "noFile": true, + "code": 2318, + "category": 1, + "messageKey": "Cannot_find_global_type_0_2318", + "messageArgs": [ + "IterableIterator" + ] + } + ] + ] + ], "affectedFilesPendingEmit": [ [ "./repro.ts", @@ -316,7 +347,7 @@ Output:: 2 ] ], - "size": 1122 + "size": 1281 } tsconfig.json:: @@ -324,15 +355,6 @@ SemanticDiagnostics:: Signatures:: -Diff:: Like Strada, the cached semantic diagnostics do not include the missing-global diagnostic produced during signature generation. ---- nonIncremental.output.txt -+++ incremental.output.txt -@@ -1,4 +0,0 @@ --error TS2318: Cannot find global type 'IterableIterator'. -- --Found 1 error. -- - Edit [3]:: delete build info to restore the semantic diagnostic //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *deleted* diff --git a/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js b/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js index af64cf4493a8d..bc2db8d85b071 100644 --- a/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js +++ b/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js @@ -105,11 +105,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -157,7 +156,7 @@ Output:: 2 ] ], - "size": 1437 + "size": 1423 } tsconfig.json:: @@ -172,60 +171,6 @@ Edit [1]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1423 -} tsconfig.json:: SemanticDiagnostics:: @@ -247,11 +192,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -299,7 +243,7 @@ Output:: 2 ] ], - "size": 1459 + "size": 1445 } tsconfig.json:: @@ -314,60 +258,6 @@ Edit [3]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1445 -} tsconfig.json:: SemanticDiagnostics:: diff --git a/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js b/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js index fdf8a7119c57e..a602b051a678c 100644 --- a/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js +++ b/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js @@ -105,11 +105,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -157,7 +156,7 @@ Output:: 2 ] ], - "size": 1473 + "size": 1459 } tsconfig.json:: @@ -172,60 +171,6 @@ Edit [1]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1459 -} tsconfig.json:: SemanticDiagnostics:: @@ -247,11 +192,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -299,7 +243,7 @@ Output:: 2 ] ], - "size": 1495 + "size": 1481 } tsconfig.json:: @@ -314,60 +258,6 @@ Edit [3]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1481 -} tsconfig.json:: SemanticDiagnostics:: diff --git a/tsc/testdata/tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts b/tsc/testdata/tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts new file mode 100644 index 0000000000000..c1ac25d7c9aa3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts @@ -0,0 +1,15 @@ +// @strict: true +// @noTypesAndSymbols: true +// @checkOrder: default, reverse, isolated, typesfirst + +declare function assertEqual(actual: unknown, expected: T): asserts actual; +declare class C {} +declare function on(cb: (e: undefined) => void): void; +declare const data: []; + +on(e => { + assertEqual(e, false); + for (;;) { + assertEqual(e as C, data); + } +}); diff --git a/tsc/testdata/tests/cases/compiler/baseConstraintDepthCheckOrder.ts b/tsc/testdata/tests/cases/compiler/baseConstraintDepthCheckOrder.ts new file mode 100644 index 0000000000000..967a50184dd64 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/baseConstraintDepthCheckOrder.ts @@ -0,0 +1,13 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { + x.length; + y.length; +} diff --git a/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts b/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts index 9b281534212e8..63dfdce226f74 100644 --- a/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts +++ b/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: esnext // @module: esnext diff --git a/tsc/testdata/tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts b/tsc/testdata/tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts new file mode 100644 index 0000000000000..a2bf3a650cc06 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts @@ -0,0 +1,83 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// The recursion of InferData and UnpackKeyValue is bounded by Next, so +// inferring it through a closure must not report it as infinite. + +type Prettify = { [K in keyof T]: T[K] } & {}; +type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; +type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; +type Next = [1, 2, 3, 4, 5, 6]; +type JSONPrimitives = string | number | bigint | boolean | null | undefined; +type JSONValues = JSONPrimitives | CanBeSerialized; +type CanBeSerialized = { + toJSON(): T; +}; +type JSONDataTypes = JSONValues | JSONDataTypes[] | { + [key: string]: JSONDataTypes; +}; +type SerializeJSONObject = { + [K in ExtractDefined]: SerializeJSONTypes; +} & { + [K in ExtractUndefined]?: SerializeJSONTypes; +}; +interface ExtendedJSONTypes { +} +type NonAllowedJSTypes = Map | Set; +type ForcefullyAllowedTypes = { + [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; +}[keyof ExtendedJSONTypes]; +type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; +type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; +interface ItemContract, MaxDepth extends Next[number], Variant extends string> { + $type: 'item'; + transformer: { + new (...args: any[]): Transformer; + }; + maxDepth: MaxDepth; + variant: Variant; +} +type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; +type LimitDepth = [ + Value +] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; +type UnpackOptionalValues = { + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; + }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; +}; +type UnpackRequiredValues = { + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; + }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; +}; +type SplitItm = [ + Extract>, + Exclude> +]; +type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; +type UnpackValues = Prettify & UnpackOptionalValues>; +type InferData = Transformer extends { + [K in Variant]: (...args: any[]) => unknown; +} ? UnpackValues>, MaxDepth, Depth> : never; +declare class Item, MaxDepth extends Next[number], Variant extends string> { + transformer: { new (...args: any[]): Transformer }; + maxDepth: MaxDepth; + variant: Variant; + $type: 'item'; + resolve(): Promise>; +} +type Ctor = { new (resource: any, ...rest: any[]): any }; +declare abstract class BaseTransformer { + static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; + constructor(resource: T); +} +class Size { +} +class SizeTransformer extends BaseTransformer { + toObject() { + } +} +declare function once(value: T): T; +once(() => SizeTransformer.transform(new Size())); diff --git a/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts b/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts index 9455c0156930f..bb7452f273d4f 100644 --- a/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts +++ b/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @Filename: weird.js // @allowJs: true diff --git a/tsc/testdata/tests/cases/compiler/checkOrderAwaitedCycle.ts b/tsc/testdata/tests/cases/compiler/checkOrderAwaitedCycle.ts new file mode 100644 index 0000000000000..f39f63e9c1f54 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderAwaitedCycle.ts @@ -0,0 +1,21 @@ +// @strict: true +// @target: esnext +// @lib: esnext +// @noEmit: true +// @checkOrder: default, reverse, isolated, typesfirst + +// Awaiting a promise whose promised type refers back to it reports a +// circularity wherever it is awaited, whichever is awaited first. + +// @filename: a.ts +type S = string | Promise; +declare const s: S; +declare const p: Promise; +async function f1() { + const a: number = await p; +} + +// @filename: b.ts +async function f2() { + const b: number = await s; +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderCircularConstraint.ts b/tsc/testdata/tests/cases/compiler/checkOrderCircularConstraint.ts new file mode 100644 index 0000000000000..efca8e2390569 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderCircularConstraint.ts @@ -0,0 +1,14 @@ +// @checkOrder: default, reverse, isolated, typesfirst + +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { + foo() { + var x!: T; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderCircularDefaults.ts b/tsc/testdata/tests/cases/compiler/checkOrderCircularDefaults.ts new file mode 100644 index 0000000000000..0232579d1f4f7 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderCircularDefaults.ts @@ -0,0 +1,16 @@ +// @strict: true +// @declaration: true +// @checkOrder: default, reverse, isolated, typesfirst + +// Which type parameter of a cycle of defaults is circular must not depend +// on which default is resolved first. + +// @filename: a.ts +import type { B } from "./b"; +export interface A { a: T } +export declare const a: A; + +// @filename: b.ts +import type { A } from "./a"; +export interface B { b: U } +export declare const b: B; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderEmitBeforeCheck.ts b/tsc/testdata/tests/cases/compiler/checkOrderEmitBeforeCheck.ts new file mode 100644 index 0000000000000..fd86103b859d3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderEmitBeforeCheck.ts @@ -0,0 +1,19 @@ +// @target: es2015 +// @declaration: true +// @checkOrder: default, isolated + +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +type Child = { [P in NonOptionalKeys]: T[P] } + +export interface ListWidget { + "type": "list", + "each": Child; +} + +type ListChild = Child + +declare let x: ListChild; +x.type; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderEnumComputedMember.ts b/tsc/testdata/tests/cases/compiler/checkOrderEnumComputedMember.ts new file mode 100644 index 0000000000000..caaa6629db492 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderEnumComputedMember.ts @@ -0,0 +1,12 @@ +// @checkOrder: default, reverse, isolated, typesfirst +// @target: esnext +// @strict: true +// @declaration: true + +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderLateBoundMembers.ts b/tsc/testdata/tests/cases/compiler/checkOrderLateBoundMembers.ts new file mode 100644 index 0000000000000..a0e4fa51e4348 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderLateBoundMembers.ts @@ -0,0 +1,13 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, reverse, isolated, typesfirst + +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +interface I { + get [foo](): number; + foo: number; + set [foo](value: number); +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderModuleExportsAlias.ts b/tsc/testdata/tests/cases/compiler/checkOrderModuleExportsAlias.ts new file mode 100644 index 0000000000000..08d9142ed1bff --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderModuleExportsAlias.ts @@ -0,0 +1,8 @@ +// @checkOrder: default, reverse, isolated, typesfirst +// @allowJs: true +// @checkJs: true +// @declaration: true +// @outDir: ./out +// @filename: index.js +module.exports.i = function i() {} +module.exports.ii = module.exports.i; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderParameterInTypeQuery.ts b/tsc/testdata/tests/cases/compiler/checkOrderParameterInTypeQuery.ts new file mode 100644 index 0000000000000..627a5ec7db84d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderParameterInTypeQuery.ts @@ -0,0 +1,19 @@ +// @strict: true +// @target: esnext +// @checkOrder: default, reverse, isolated, typesfirst + +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { + #a = 1; + test1() { + class C { + test1(a: C2): typeof a.#a { + return 1; + } + } + return new C().test1(this); + } +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts b/tsc/testdata/tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts new file mode 100644 index 0000000000000..68f93ef70343d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts @@ -0,0 +1,21 @@ +// @noEmit: true +// @strict: true +// @checkOrder: default, reverse, isolated, typesfirst + +// @filename: recur.ts +export type Recur = + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + +// @filename: join.ts +import { Recur } from "./recur"; +export function join(l: Recur[]): Recur { + return ['marker', ...l]; +} + +// @filename: a.ts +import { Recur } from "./recur"; +import { join } from "./join"; +function a(l: Recur[]): void { + const x: Recur | undefined = join(l); +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderSpreadCycle.ts b/tsc/testdata/tests/cases/compiler/checkOrderSpreadCycle.ts new file mode 100644 index 0000000000000..b9c220019d68b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderSpreadCycle.ts @@ -0,0 +1,31 @@ +// @checkOrder: default, reverse, isolated, typesfirst +// @strict: true +// @module: commonjs +// @target: es2020 +// @allowJs: true +// @declaration: true +// @outDir: /out +// @noImplicitReferences: true + +// @Filename: /ma.js +export { v as pa } from "./xa"; +export const ma = 1; + +// @Filename: /mb.js +export { v as pb } from "./xb"; +export const mb = 1; + +// @Filename: /xa.js +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +// @Filename: /xb.js +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +// @Filename: /ia.js +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderStableInstantiationErrors.ts b/tsc/testdata/tests/cases/compiler/checkOrderStableInstantiationErrors.ts new file mode 100644 index 0000000000000..1cdffd661c908 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderStableInstantiationErrors.ts @@ -0,0 +1,30 @@ +// @checkOrder: default, reverse, typesfirst +// @filename: lib.ts +export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +// @filename: a.ts +import { Recur } from "./lib"; +export let a: Recur<5, "a">; + +// @filename: b.ts +import { Recur } from "./lib"; +export let b: Recur<5, "a">; + +// @filename: c.ts +class T { + declare a: A; + declare b: any; +} +class L extends T {} +export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } +} diff --git a/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts b/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts index 01a0d10ffe3d7..76a644bb35537 100644 --- a/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts +++ b/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true // @declaration: true diff --git a/tsc/testdata/tests/cases/compiler/circularIndexedPropertyInstantiation.ts b/tsc/testdata/tests/cases/compiler/circularIndexedPropertyInstantiation.ts new file mode 100644 index 0000000000000..3aa2e3f2b6f02 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularIndexedPropertyInstantiation.ts @@ -0,0 +1,6 @@ +// @target: es2015 +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +let f1: Foo<"true", {}>; +let f2: Foo<"false", {}>; \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/circularInitializerInference.ts b/tsc/testdata/tests/cases/compiler/circularInitializerInference.ts new file mode 100644 index 0000000000000..727b206a54e83 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularInitializerInference.ts @@ -0,0 +1,31 @@ +// @target: es2015 +// @strict: true, false + +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +type Assert = Condition; + +var comma = (comma, 3); +type CommaInference = Assert>; + +var nestedComma = (comma, nestedComma, comma); +type NestedCommaInference = Assert>; + +var assignment = (assignment = 2); +type AssignmentInference = Assert>; + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +type NestedAssignmentInference = Assert>; + +var conditional = conditional ? 0 : 1; +type ConditionalInference = Assert>; + +var logicalAnd = logicalAnd && ""; +type LogicalAndInference = Assert>; + +var propertyAccess = { member: propertyAccess.member }; +type PropertyAccessInference = Assert>; + +const nonCircular: number = 3; +type NonCircularInference = Assert extends false ? true : false>; \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts b/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts index 2bc4f70704151..251464912be0f 100644 --- a/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts +++ b/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true // @noEmit: true diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts new file mode 100644 index 0000000000000..76e977a6505b1 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts @@ -0,0 +1,42 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +// @filename: expression.ts +// Subtype reduction of rebuild's return type relates the class to A, +// which needs b's return type, which needs rebuild's: a cycle. Both +// members report it, whichever return type is requested first, as if +// rebuild's, declared first, were requested first. +interface A { + b(): A; + c: A; +} +declare const flag: boolean; +const A: new () => A = class { + rebuild() { + return flag ? this : new A(); + } + b() { + return this.rebuild(); + } + c() { + return this.rebuild; + } +}; +export {}; + +// @filename: declaration.ts +interface B { + b(): B; +} +declare const flag: boolean; +class K { + rebuild() { + return flag ? this : new B(); + } + b() { + return this.rebuild(); + } +} +const B: new () => B = K; +export {}; diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts new file mode 100644 index 0000000000000..14bc012218d93 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts @@ -0,0 +1,44 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +declare function config(config: { f?: () => Base }): void; + +declare const h: Heading; +const b: Base = h; + +class Heading { + m() { + return config({ f: () => create() }); + } +} + +declare function create(): Heading; + +const r: void = new Heading().m(); + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +type AST = NullNode | UndefinedNode; +declare function fromConst(ast: AST, value: unknown): Parser; + +const NullNode: new () => NullNode = class { + readonly _tag = "Null"; + getParser() { + return fromConst(this, null); + } +}; + +const p: Parser = new NullNode().getParser(); diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts new file mode 100644 index 0000000000000..209bc9616d71d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts @@ -0,0 +1,27 @@ +// @strict: true,false +// @noEmit: true + +declare function fan(g: () => number): number; + +export function a(n: number) { + return fan(() => a(n)); +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; + +export async function b(n: number) { + if (n > 0) { + return fanAll(() => b(n - 1)); + } + return { ok: true }; +} + +type Result = { success: boolean; [key: string]: unknown }; +interface Other { success: boolean; url: string } +declare function fanOut(generateOne: () => Promise): Promise; +declare const other: Other; + +export async function c(n: number) { + if (n) return other; + return fanOut(() => c(n - 1)); +} diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts new file mode 100644 index 0000000000000..cd367b30e1c03 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts @@ -0,0 +1,22 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); + +declare function materialize(extra: { next?: (id: string) => unknown }): number; + +function getCreds() { + const next = (id: string) => getCreds(); + return materialize({ next }); +} + +const n: number = getCreds(); diff --git a/tsc/testdata/tests/cases/compiler/circularScopeThunkReverseMapped.ts b/tsc/testdata/tests/cases/compiler/circularScopeThunkReverseMapped.ts new file mode 100644 index 0000000000000..273d8a44b93d3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularScopeThunkReverseMapped.ts @@ -0,0 +1,26 @@ +// @strict: true +// @target: esnext +// @noEmit: true +// @checkOrder: default, typesfirst + +type Resolve = T extends () => infer R ? R : T; +type Validate = { [K in keyof def]: def[K] extends () => infer R ? () => R : def[K] }; +interface Scope { + type(k: k): Resolve; +} +interface Type { + pipe(f: (x: T) => U): Type; +} +declare function scope(def: Validate): Scope; +declare function type(x: T): Type; + +export const $ = scope({ + a: type("string").pipe(function (s) { return s.length; }), + b: () => $.type("a").pipe(function (n) { return n === 0; }), +}); + +// Entered from the function in the first property when queried in reverse +export const $2 = scope({ + a: type("string").pipe(function (s) { return s.length; }), + b: () => $2.type("a").pipe((n: number) => n === 0), +}); diff --git a/tsc/testdata/tests/cases/compiler/classCircularityDiagnostics.ts b/tsc/testdata/tests/cases/compiler/classCircularityDiagnostics.ts new file mode 100644 index 0000000000000..34977b5df2a3d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/classCircularityDiagnostics.ts @@ -0,0 +1,48 @@ +// @target: esnext +// @noImplicitAny: true, false + +class Direct extends Direct { + static value = 1; + value = 2; +} + +const staticValue = Direct.value; +const instanceValue = new Direct().value; + +class First extends Second {} +class Second extends First {} + +const Expression = class Named extends Named {}; + +class NestedBase extends (class { + static value = 1; + value = 2; +}) {} + +const nestedStaticValue: number = NestedBase.value; +const nestedInstanceValue: number = new NestedBase().value; + +const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; +}) {}; + +const selfConstructor = SelfReferencingBase.self; + +function mixin {}>(base: Base) { + return class extends base { + static value = 1; + value = 2; + }; +} + +class Mixed extends mixin(NestedBase) {} + +const mixedStaticValue: number = Mixed.value; +const mixedInstanceValue: number = new Mixed().value; + +declare function makeBase(value: number): typeof NestedBase; +class InvalidBaseArgument extends makeBase("invalid") {} +const InvalidExpressionArgument = class extends makeBase("invalid") {}; + +declare function makeInvalidBase(value: number): number; +class InvalidConstructor extends makeInvalidBase("invalid") {} \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/clonedTypeParameterUnionOrder.ts b/tsc/testdata/tests/cases/compiler/clonedTypeParameterUnionOrder.ts new file mode 100644 index 0000000000000..3bfa464b30bde --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/clonedTypeParameterUnionOrder.ts @@ -0,0 +1,15 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, reverse, typesfirst + +// @filename: a.ts +interface Pair { a: A; b: B } +interface Box { m(x: T): Pair } +declare function call(f: (x: A) => R): (x: A) => R; +declare const bs: Box; +declare const bn: Box; +const n = call(bn.m); + +// @filename: b.ts +declare const c: boolean; +const r = c ? call(bs.m) : call(bn.m); diff --git a/tsc/testdata/tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts b/tsc/testdata/tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts new file mode 100644 index 0000000000000..42517d7d60024 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts @@ -0,0 +1,11 @@ +// @strict: true +// @target: esnext +// @lib: esnext +// @noEmit: true +// @checkOrder: default, typesfirst + +declare function settle(fn: () => T): Promise<{ [K in keyof T]: [Awaited] }>; + +async function f() { + const [[a], b] = await settle(() => [Promise.resolve(0), Promise.reject(1)] as const); +} diff --git a/tsc/testdata/tests/cases/compiler/contextualCheckInDiscardedCycle.ts b/tsc/testdata/tests/cases/compiler/contextualCheckInDiscardedCycle.ts new file mode 100644 index 0000000000000..f7ecd882156e7 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualCheckInDiscardedCycle.ts @@ -0,0 +1,39 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +// @filename: returnTypeCycle.ts +// Callbacks contextually checked while a cycle is in progress are checked +// again once it is discarded, with their contextual parameter types. + +declare function useCallback(callback: T): T; +declare function refreshAll(options: { ids: string[]; extra: T }): Promise; + +interface View { + refresh: (force?: boolean) => Promise; +} + +declare const items: { id: string }[]; + +function useView(): View { + const refresh = useCallback((force?: boolean) => + refreshAll({ + ids: items.map(({ id }) => id), + extra: 1, + })); + return { refresh }; +} + +// @filename: yieldOperandCycle.ts +interface Eff { + [Symbol.iterator](): Generator, A, any>; + pipe(f: (self: Eff) => B): B; +} +declare function mapError(f: (e: E) => E2): (self: Eff) => Eff; +declare function fn(body: (input: number) => Generator): (input: number) => Eff; +declare function make(s: T): T; +declare const uuid: Eff; + +fn(function* (input) { + make(yield* uuid.pipe(mapError((cause) => ({ cause })))); +}); diff --git a/tsc/testdata/tests/cases/compiler/contextualCheckReentryAfterParameters.ts b/tsc/testdata/tests/cases/compiler/contextualCheckReentryAfterParameters.ts new file mode 100644 index 0000000000000..3d4cac45ed898 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualCheckReentryAfterParameters.ts @@ -0,0 +1,41 @@ +// @strict: true +// @noEmit: true + +// Instantiating the type predicate inside the nested callback re-enters the +// contextual check of the enclosing functions through their outer type +// parameters. That must not discard the parameter types assigned to them. + +type Surface = { id: string; kind: "file"; path: string } | { id: string; kind: "terminal" }; +interface Panel { + surfaces: Surface[]; +} +interface Store { + panel: Panel; + openFile: (path: string) => void; + close: (id: string) => void; +} +type Creator = (set: (update: (state: T) => Partial) => void) => T; +declare function create(init: Creator): T; +declare function wrap(init: Creator): Creator; + +const update = (state: Store, updater: (current: Panel) => Panel): Partial => ({ panel: updater(state.panel) }); + +export const store = create(wrap((set) => ({ + panel: { surfaces: [] }, + openFile: (path) => + set((state) => + update(state, (current) => { + const existing = current.surfaces.find( + (surface): surface is Extract => surface.kind === "file" && surface.path === path, + ); + return existing ? current : { surfaces: [...current.surfaces, { id: path, kind: "file", path }] }; + }) + ), + close: (id) => + set((state) => + update(state, (current) => { + const index = current.surfaces.findIndex((entry) => entry.id === id); + return { surfaces: current.surfaces.slice(index) }; + }) + ), +}))); diff --git a/tsc/testdata/tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts b/tsc/testdata/tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts new file mode 100644 index 0000000000000..4d185d6668c8a --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true + +interface Argv { + command(builder: (args: Argv) => Argv, handler: (args: Arguments) => void): Argv; + option(key: K, options: O): Argv<{ [key in K]: O } & Check>; +} +type Arguments = { [key in keyof T]: T[key] } & { [key: string]: unknown }; +type Check = O extends {} ? {} : {}; +declare const yargs: Argv; + +yargs.command( + (yargs) => yargs.option("a", { type: "string" }), + (argv) => { + const a: { type: string } = argv.a; + }, +); diff --git a/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts b/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts index a6ff9ae0a6e48..3ca7c15a2d58c 100644 --- a/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts +++ b/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true // @noemit: true @@ -27,3 +28,8 @@ const obj: { f: (x: T) => void } = { type IsObject = { x: typeof t } extends { x: string } ? true : false; } }; + +f(function self(t) { + const s = self; + type P = Parameters; +}); diff --git a/tsc/testdata/tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts b/tsc/testdata/tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts new file mode 100644 index 0000000000000..9fd41e7b8b38e --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts @@ -0,0 +1,7 @@ +// @checkOrder: default, typesfirst + +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; diff --git a/tsc/testdata/tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts b/tsc/testdata/tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts new file mode 100644 index 0000000000000..778d3f13cf9b3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts @@ -0,0 +1,20 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; + +interface Store { + a: (x: boolean) => void; + b: (y: string) => void; +} + +const store = create(() => ({ + a: (x) => store.b(""), + b: (y) => {}, +})); diff --git a/tsc/testdata/tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts b/tsc/testdata/tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts new file mode 100644 index 0000000000000..aeec88e3ef5b1 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { + initialState: S; + reducers: CR; +}): CR; +declare function g(a: T): void; + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); diff --git a/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts b/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts index 04519047a9dc7..62b911890c1ed 100644 --- a/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts +++ b/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @strict: true interface Matcher { diff --git a/tsc/testdata/tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts b/tsc/testdata/tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts new file mode 100644 index 0000000000000..d047462f7c312 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts @@ -0,0 +1,18 @@ +// @strict: true + +enum Kind { A, B } + +interface ItemA { kind: Kind.A; name: string } +interface ItemB { kind: Kind.B; size: number } +type Item = ItemA | ItemB; + +declare function create(options: { items?: () => readonly Item[]; label: string }): void; + +function test(flag: boolean) { + create({ + label: "x", + ...(flag ? {} : { + items: () => [{ kind: Kind.A, name: "a" }], + }), + }); +} diff --git a/tsc/testdata/tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts b/tsc/testdata/tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts new file mode 100644 index 0000000000000..7a15bdde8b6f7 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts @@ -0,0 +1,16 @@ +// @checkOrder: default, typesfirst + +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { + p: E["p"]; +} +declare class E extends mix(Base) { + p: number; +} +declare function mix object>(x: T): T; +declare class Base { + constructor(arg?: InstanceType); +} diff --git a/tsc/testdata/tests/cases/compiler/deferredTypeReferenceCycleRollback.ts b/tsc/testdata/tests/cases/compiler/deferredTypeReferenceCycleRollback.ts new file mode 100644 index 0000000000000..a33318012116f --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/deferredTypeReferenceCycleRollback.ts @@ -0,0 +1,20 @@ +// @strict: true +// @noEmit: true + +// A cycle rollback used to reset the type of the Array> +// node while the deferred reference identified by that node survived, +// which crashed a later instantiation of it. + +declare function declare(): void; + +interface PluginObj { + visitor: Visit; +} +type Visit = VisitFn | VisitObj; +type VisitFn = (path: NodePath

) => void; +interface VisitObj {} +declare class NodePath { + parentPath: NodePath>; + get: Get; +} +type Get = T extends Array ? Array> : never; diff --git a/tsc/testdata/tests/cases/compiler/deleteExpressionMustBeOptional.ts b/tsc/testdata/tests/cases/compiler/deleteExpressionMustBeOptional.ts index 223e0027de3cb..3252460f3281f 100644 --- a/tsc/testdata/tests/cases/compiler/deleteExpressionMustBeOptional.ts +++ b/tsc/testdata/tests/cases/compiler/deleteExpressionMustBeOptional.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true, false diff --git a/tsc/testdata/tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts b/tsc/testdata/tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts index 7006dffe572ca..4272774ef918b 100644 --- a/tsc/testdata/tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts +++ b/tsc/testdata/tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts @@ -1,5 +1,6 @@ // @strict: true // @noEmit: true +// @checkOrder: default, typesfirst type U = | { kind: "a"; payload: number; extra?: unknown } diff --git a/tsc/testdata/tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts b/tsc/testdata/tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts new file mode 100644 index 0000000000000..8ca726e50e3ee --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true + +// The base constraint of Collect is circular, since its +// constraint includes Collect, whose constraint includes itself. +// Distributing Parameters over that constraint leads back into the +// circularity, so Parameters> must instead have the +// constraint of its branches, unknown[], and be spreadable. + +type Collect = + Result & F extends (arg: infer A) => infer R + ? Collect | (() => R) + : never; + +function pipe unknown>(args: Parameters>, f: F) { + f(...args); +} diff --git a/tsc/testdata/tests/cases/compiler/enumMemberTypeCacheConsistency.ts b/tsc/testdata/tests/cases/compiler/enumMemberTypeCacheConsistency.ts new file mode 100644 index 0000000000000..74c113fe04cde --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/enumMemberTypeCacheConsistency.ts @@ -0,0 +1,11 @@ +// @target: esnext +// @strict: true +// @declaration: true + +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/evolvingArrayReadInLoopCondition.ts b/tsc/testdata/tests/cases/compiler/evolvingArrayReadInLoopCondition.ts new file mode 100644 index 0000000000000..dd6f0e7f1fea1 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/evolvingArrayReadInLoopCondition.ts @@ -0,0 +1,16 @@ +// @strict: true +// @noEmit: true + +// Narrowing by the condition needs the type of `seen` at the call, which +// depends on the analysis of the loop in progress for that same read. Once +// the loop is analyzed, `seen` is number[] there, so no error should say that +// its type cannot be determined. + +declare const x: number; +const seen = []; +for (let i = 0; i < 3; i++) { + if (!seen.some(s => true)) { + seen.push(x); + } +} +const result = seen; diff --git a/tsc/testdata/tests/cases/compiler/excessivelyLargeTupleSpread.ts b/tsc/testdata/tests/cases/compiler/excessivelyLargeTupleSpread.ts index aba0de7b9b952..d8ec361ce08f3 100644 --- a/tsc/testdata/tests/cases/compiler/excessivelyLargeTupleSpread.ts +++ b/tsc/testdata/tests/cases/compiler/excessivelyLargeTupleSpread.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // #41771 diff --git a/tsc/testdata/tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts b/tsc/testdata/tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts index 86492e6c43f58..f3215225893b1 100644 --- a/tsc/testdata/tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts +++ b/tsc/testdata/tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true diff --git a/tsc/testdata/tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts b/tsc/testdata/tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts new file mode 100644 index 0000000000000..9b4a415d9bcbb --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts @@ -0,0 +1,17 @@ +// @target: es2015 +// @module: commonjs +// @declaration: true +// @checkOrder: default,editorfirst + +namespace m { + export interface Inner { + x: number; + } + export interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; diff --git a/tsc/testdata/tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts b/tsc/testdata/tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts index 446b9319461cc..1a5a311e5c0dc 100644 --- a/tsc/testdata/tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts +++ b/tsc/testdata/tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 declare function trans(f: (x: T) => string): number; trans(({a}) => a); diff --git a/tsc/testdata/tests/cases/compiler/fixingTypeParametersRepeatedly2.ts b/tsc/testdata/tests/cases/compiler/fixingTypeParametersRepeatedly2.ts index c1949e48bf2ff..acb671e7cb0c2 100644 --- a/tsc/testdata/tests/cases/compiler/fixingTypeParametersRepeatedly2.ts +++ b/tsc/testdata/tests/cases/compiler/fixingTypeParametersRepeatedly2.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: false interface Base { diff --git a/tsc/testdata/tests/cases/compiler/flowLoopDepthCheckOrder.ts b/tsc/testdata/tests/cases/compiler/flowLoopDepthCheckOrder.ts new file mode 100644 index 0000000000000..4be32972e0a81 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/flowLoopDepthCheckOrder.ts @@ -0,0 +1,1028 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +declare let b: boolean; + +let x: string | number = 0; +while (cond()) { + if (typeof x === "string") { x = 1; } else { x = "a"; } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} +} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +if (b) {} +const deep = x; diff --git a/tsc/testdata/tests/cases/compiler/flowLoopTooDeepCheckOrder.ts b/tsc/testdata/tests/cases/compiler/flowLoopTooDeepCheckOrder.ts new file mode 100644 index 0000000000000..b5287e1da984c --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/flowLoopTooDeepCheckOrder.ts @@ -0,0 +1,1123 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +declare function isString(value: unknown): value is string; +declare let b: boolean; + +let w: string | number = 0; +while (cond()) { + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (typeof w === "string") { w = 1; } else { w = "a"; } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} +} +if (isString(w)) { + const narrowed = w; +} diff --git a/tsc/testdata/tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts b/tsc/testdata/tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts new file mode 100644 index 0000000000000..91e8220f031aa --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts @@ -0,0 +1,28 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; + +id(() => { + return (x = false) => {}; +}); + +id(() => (y = false) => y); + +id(() => { + return { m(z = false) {} }; +}); + +const r = id(() => { + return (w = 0) => {}; +}); +r()(""); diff --git a/tsc/testdata/tests/cases/compiler/getterCircularityDiagnostics.ts b/tsc/testdata/tests/cases/compiler/getterCircularityDiagnostics.ts new file mode 100644 index 0000000000000..f5533c69336ad --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/getterCircularityDiagnostics.ts @@ -0,0 +1,14 @@ +// @target: es2015 +// @strict: true + +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/getterReturnTypeQueryOrder.ts b/tsc/testdata/tests/cases/compiler/getterReturnTypeQueryOrder.ts new file mode 100644 index 0000000000000..25228f5dd95b5 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/getterReturnTypeQueryOrder.ts @@ -0,0 +1,15 @@ +// @target: es2015 +// @strict: true +// @checkOrder: default,editorfirst + +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} diff --git a/tsc/testdata/tests/cases/compiler/importAttributeValueCheckOrder.ts b/tsc/testdata/tests/cases/compiler/importAttributeValueCheckOrder.ts new file mode 100644 index 0000000000000..c932f5e489893 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/importAttributeValueCheckOrder.ts @@ -0,0 +1,8 @@ +// @checkOrder: default, typesfirst +// @target: esnext + +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; diff --git a/tsc/testdata/tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts b/tsc/testdata/tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts new file mode 100644 index 0000000000000..c42fef6accd0b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts @@ -0,0 +1,23 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// The type of data in TokenNode is assignable to its inherited index +// signature, which mentions it through an indexed access. + +interface BaseNode { + kind: string; + [key: string]: string | TokenNode["data"]; +} + +interface TokenNode extends BaseNode { + kind: 'token'; + data: TokenData; +} + +interface TokenData { + offset: number; + width: number; + leading_width: number; + trailing_width: number; +} diff --git a/tsc/testdata/tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts b/tsc/testdata/tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts new file mode 100644 index 0000000000000..b0876e1a14d68 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts @@ -0,0 +1,13 @@ +// @strict: true +// @noUncheckedIndexedAccess: true +// @noEmit: true +// @checkOrder: default, typesfirst + +function f, K extends keyof T>(obj: T, k: K, b: boolean) { + const x = b ? obj[k] : g(); + const s1: string = x; + const y = b ? g() : obj[k]; + const s2: string = y; +} + +declare function g(): T[K]; diff --git a/tsc/testdata/tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts b/tsc/testdata/tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts new file mode 100644 index 0000000000000..2ecccbeddd0a2 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts @@ -0,0 +1,10 @@ +// @checkOrder: default, typesfirst + +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +type S = Copy<{ x: 0 } & T>; +type I = {} extends S ? U : never; diff --git a/tsc/testdata/tests/cases/compiler/inferenceDeeplyNestedCheckOrder.ts b/tsc/testdata/tests/cases/compiler/inferenceDeeplyNestedCheckOrder.ts new file mode 100644 index 0000000000000..9771e61448026 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/inferenceDeeplyNestedCheckOrder.ts @@ -0,0 +1,23 @@ +// @strict: true +// @target: es2015 +// @noEmit: true + +// Inferring from string[][] to Iterable> recurses through the +// [Symbol.iterator] methods of both arrays. Whether that looks like expanding +// recursion must not depend on whether string[] was iterated beforehand. + +// @filename: first.ts +declare function flatten1(iterable: Iterable>): T[]; +declare const lists1: string[][]; +const flat1: null = flatten1(lists1); + +declare const items1: string[]; +for (const item of items1) {} + +// @filename: second.ts +declare const items2: number[]; +for (const item of items2) {} + +declare function flatten2(iterable: Iterable>): T[]; +declare const lists2: number[][]; +const flat2: null = flatten2(lists2); diff --git a/tsc/testdata/tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts b/tsc/testdata/tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts new file mode 100644 index 0000000000000..5688826ba7da9 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts @@ -0,0 +1,10 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// Inferring from Promise to PromiseLike | V must infer V as string, +// whichever order the union's members are in. + +declare function props(x: PromiseLike | V>>): Promise>; +declare const input: Promise>>; +const out: Promise> = props(input); diff --git a/tsc/testdata/tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts b/tsc/testdata/tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts new file mode 100644 index 0000000000000..e769205507ed3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts @@ -0,0 +1,21 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// Sorting the array made from a flattened iterable must keep its element type. + +function getAllValuesUnsorted(m: ReadonlyArray>): ReadonlyArray { + // OK + return Array.from(flatten(m.values())) +} + +function getAllValuesSorted(m: ReadonlyArray>): ReadonlyArray { + // Type 'unknown[]' is not assignable to type 'readonly string[]'. + return Array.from(flatten(m.values())).sort() +} + +function* flatten(a: Iterable>): Iterable { + for (const xs of a) + for (const x of xs) + yield x +} diff --git a/tsc/testdata/tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts b/tsc/testdata/tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts new file mode 100644 index 0000000000000..c845b6d929174 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts @@ -0,0 +1,22 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +fromMetadata(a); +type DeepPartial = { [P in keyof T]: DeepPartial }; +type Nested = Nested[]; +interface Prop { owner: Meta } +interface Meta { + prop: Prop; + other: any; + query: Query; +} +type Query = { cond: Nested }; +declare function fromMetadata(meta: Meta | DeepPartial>): void; diff --git a/tsc/testdata/tests/cases/compiler/instantiationCountSharedCheckOrder.ts b/tsc/testdata/tests/cases/compiler/instantiationCountSharedCheckOrder.ts new file mode 100644 index 0000000000000..da9adbef59255 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/instantiationCountSharedCheckOrder.ts @@ -0,0 +1,14 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +type K = `${D}${D}${D}`; +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +type Rest = Wide<[0, 0], "a">; +type All = Wide<[], "a">; diff --git a/tsc/testdata/tests/cases/compiler/instantiationDepthSharedCheckOrder.ts b/tsc/testdata/tests/cases/compiler/instantiationDepthSharedCheckOrder.ts new file mode 100644 index 0000000000000..28d33bc515e68 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/instantiationDepthSharedCheckOrder.ts @@ -0,0 +1,14 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +type DeepAll = Deep<[]>; diff --git a/tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts b/tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts new file mode 100644 index 0000000000000..e10b5e3a39e74 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts @@ -0,0 +1,24 @@ +// @checkOrder: default, typesfirst + +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + } +} + +namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + static B = class B { + parent!: T; + }; + } +} diff --git a/tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts b/tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts new file mode 100644 index 0000000000000..34639716c8343 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts @@ -0,0 +1,15 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// A does not satisfy the constraint A of B, as T is not assignable to +// number, which must be reported. + +class A { + value!: T; + child!: InstanceType>>; // this should error + + static B = class B { + parent!: T; + }; +} diff --git a/tsc/testdata/tests/cases/compiler/instantiationLimitsCheckOrder.ts b/tsc/testdata/tests/cases/compiler/instantiationLimitsCheckOrder.ts new file mode 100644 index 0000000000000..d20851bc88553 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/instantiationLimitsCheckOrder.ts @@ -0,0 +1,19 @@ +// @noEmit: true + +// The depth limit on instantiations must not depend on what was +// instantiated before. The limit on the number of instantiations does, as +// it only stops runaway instantiations, so it is only tested for a single +// statement whose work nothing else shares. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +type K = `${D}${D}${D}`; + +// Several million instantiations, well over the limit, for one statement. +type Wide = N["length"] extends 8 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K]; +type WideAll = Wide<[], "">; + +// Over a hundred nested instantiations, half of which already happened for +// another statement. +type Deep = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"]; +type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +type DeepAll = Deep<[]>; diff --git a/tsc/testdata/tests/cases/compiler/instantiationStackLimitCheckOrder.ts b/tsc/testdata/tests/cases/compiler/instantiationStackLimitCheckOrder.ts new file mode 100644 index 0000000000000..a070915263117 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/instantiationStackLimitCheckOrder.ts @@ -0,0 +1,18 @@ +// @noEmit: true +// @target: esnext +// @checkOrder: default, typesfirst + +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +type X = F<[]>; + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +const r = ([] as A).flat(Infinity); diff --git a/tsc/testdata/tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts b/tsc/testdata/tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts new file mode 100644 index 0000000000000..891ce94838f81 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts @@ -0,0 +1,8 @@ +// @checkOrder: default, typesfirst + +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +declare class C extends B { p: number; } diff --git a/tsc/testdata/tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts b/tsc/testdata/tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts new file mode 100644 index 0000000000000..33c25e649c64e --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts @@ -0,0 +1,13 @@ +// @target: esnext +// @checkJs: true +// @noImplicitAny: true +// @outDir: out +// @filename: file.js + +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { + const properties = {}; + const pixel = properties[axis] = value; + const otherPixel = properties[axis] = value; + properties.skip = isNaN(pixel) || isNaN(otherPixel); +} \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts b/tsc/testdata/tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts new file mode 100644 index 0000000000000..c722eee6a0c8b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts @@ -0,0 +1,13 @@ +// @module: commonjs +// @target: es2015 +// @checkOrder: default,editorfirst +// @filename: /a.ts +export interface A {} + +// @filename: /b.ts +import * as a from "./a"; + +/** + * See {@link a.A}. + */ +export function foo() {} diff --git a/tsc/testdata/tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts b/tsc/testdata/tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts new file mode 100644 index 0000000000000..fdf0661ace752 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts @@ -0,0 +1,17 @@ +// @allowJs: true +// @checkJs: true +// @noEmit: true +// @strict: true + +// @filename: a.js +/** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ +const context = { f: (a) => "" }; + +context.f = + /** @type {(content: string, ...rest: [boolean?]) => string} */ + (content, ...rest) => content.toUpperCase() + rest.length; + +/** @type {(content: string | number) => string} */ +const g = + /** @type {(content: string) => string} */ + (content) => content.toUpperCase(); diff --git a/tsc/testdata/tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx b/tsc/testdata/tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx index 652316735d2e8..09c7889d5aa04 100644 --- a/tsc/testdata/tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx +++ b/tsc/testdata/tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @module: commonjs // @target: es2015 // @jsx: preserve diff --git a/tsc/testdata/tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx b/tsc/testdata/tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx index 52bd71073ce20..2ddc4427d5056 100644 --- a/tsc/testdata/tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx +++ b/tsc/testdata/tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @jsx: preserve diff --git a/tsc/testdata/tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts b/tsc/testdata/tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts new file mode 100644 index 0000000000000..1e940b2075e12 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts @@ -0,0 +1,10 @@ +// @noEmit: true +// @checkOrder: default, typesfirst + +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +type S = keyof C; +const k: S = 123; diff --git a/tsc/testdata/tests/cases/compiler/lateBoundMutualMemberTables.ts b/tsc/testdata/tests/cases/compiler/lateBoundMutualMemberTables.ts new file mode 100644 index 0000000000000..24336a6a9155b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/lateBoundMutualMemberTables.ts @@ -0,0 +1,20 @@ +// @target: esnext +// @strict: true +// @declaration: true + +declare const a: A<"a">; +declare const b: B<"b">; +declare class A { + x: T; + [b.y]: "fromB"; + [b.by]: "fromB2"; +} +declare class B { + y: T; + [a.x]: "fromA"; + [a.b]: "fromA2"; +} +export const v1 = a.b; +export const v2 = b.a; +export const v3 = a.fromA2; +export const v4 = b.fromB; diff --git a/tsc/testdata/tests/cases/compiler/limitDeepInstantiations.ts b/tsc/testdata/tests/cases/compiler/limitDeepInstantiations.ts index ccb48dec686eb..ba5c710c6fed3 100644 --- a/tsc/testdata/tests/cases/compiler/limitDeepInstantiations.ts +++ b/tsc/testdata/tests/cases/compiler/limitDeepInstantiations.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // Repro from #14837 diff --git a/tsc/testdata/tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts b/tsc/testdata/tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts new file mode 100644 index 0000000000000..46b9086842fb1 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts @@ -0,0 +1,22 @@ +// @strict: true +// @noEmit: true + +// value_def is never inside the if. With a && condition, main and +// Strada leak the loop analysis's incomplete never placeholder +// (silentNever), so the property access is silently allowed and only +// the assignment errors. With `while (x)` they report the access. +function f(x: boolean, y: boolean) { + let value_def: { last_ref: boolean } | null = null; + if (value_def) { + while (x && y); + value_def.last_ref = false; + } +} + +function g(x: boolean) { + let value_def: { last_ref: boolean } | null = null; + if (value_def) { + while (x); + value_def.last_ref = false; + } +} diff --git a/tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts b/tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts new file mode 100644 index 0000000000000..5f8c2da7a3dc4 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts @@ -0,0 +1,21 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +declare function wrap(f: U): U; +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +declare function tagWrap(s: TemplateStringsArray, f: U): U; + +outer(wrap((x) => x.toFixed())!, 1); +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +tag`${wrap((x) => x.toFixed())}${1}`; +outer(tagWrap`${(x) => x.toFixed()}`, 1); +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); diff --git a/tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx b/tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx new file mode 100644 index 0000000000000..81df629a1c7c3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true +// @jsx: preserve +// @checkOrder: default, typesfirst + +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { + interface Element {} + interface IntrinsicElements {} +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +declare function wrap(f: U): U; + +const a = x.toFixed())} v={1} />; +const b = x.toFixed()) }} v={1} />; diff --git a/tsc/testdata/tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts b/tsc/testdata/tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts new file mode 100644 index 0000000000000..4c0a31553c354 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts @@ -0,0 +1,32 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// Assigning DataTypeThree to DataTypeThree, and likewise for +// DataTypeTwo, must be reported whether or not earlier assignments errored. + +type TypeA = number; +type TypeB = boolean; +type DataTypeTwo = { + one: Array<{ two: Array }>; +}; +type DataTypeThree = { + one: Array<{ two: Array<{ three: Array }> }>; +}; + +let testingThreeErr: DataTypeThree = { + one: [{ two: [{ three: [true] }] }] +}; +let testingTwoErr: DataTypeTwo = { + one: [{ two: [false] }] +}; + +let testingThree: DataTypeThree = { + one: [{ two: [{ three: [5] }] }] +}; +let t3a: DataTypeThree = testingThree; + +let testingTwo: DataTypeTwo = { + one: [{ two: [5] }] +}; +let t2a: DataTypeTwo = testingTwo; diff --git a/tsc/testdata/tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts b/tsc/testdata/tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts new file mode 100644 index 0000000000000..2074b9f29a2c4 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts @@ -0,0 +1,10 @@ +// @strict: true +// @checkOrder: default, typesfirst + +declare const b: boolean; +let x; +x = { a: 1 }; +let arr = []; +arr.push(x); // regular copy of the literal +const y = x; // widened copy of the literal +const z = b ? (b ? arr[0] : y) : { c: 1 }; diff --git a/tsc/testdata/tests/cases/compiler/objectRestUnionInstantiationOrder.ts b/tsc/testdata/tests/cases/compiler/objectRestUnionInstantiationOrder.ts new file mode 100644 index 0000000000000..9a8421765dd31 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/objectRestUnionInstantiationOrder.ts @@ -0,0 +1,11 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +function f(v: { k: "a"; a: T } | { k: "b"; b: number }) { + const { k, ...rest } = v; + return { all: rest, onlyB: "b" in rest ? rest : undefined }; +} +const o = f({ k: "a", a: "s" }); +const all = o.all; +const onlyB = o.onlyB; diff --git a/tsc/testdata/tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts b/tsc/testdata/tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts index 5c46a93180392..6265ebecee02e 100644 --- a/tsc/testdata/tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts +++ b/tsc/testdata/tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: false interface A { x } diff --git a/tsc/testdata/tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts b/tsc/testdata/tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts new file mode 100644 index 0000000000000..388af19a9c64c --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts @@ -0,0 +1,25 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; + +function direct({ a = 1 as number | undefined, b = a } = {}) { + const n: string = b; +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { + const n: string = b; +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { + const n: string = b; +} diff --git a/tsc/testdata/tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts b/tsc/testdata/tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts new file mode 100644 index 0000000000000..02928caa7865f --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts @@ -0,0 +1,8 @@ +// @checkOrder: default, typesfirst + +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +declare namespace n {} diff --git a/tsc/testdata/tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts b/tsc/testdata/tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts new file mode 100644 index 0000000000000..6bf2640a5b429 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// The assignment is valid, as method parameters are compared bivariantly, and +// must be accepted whichever of the interfaces is declared first. + +type M = { kind: "m" }; +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +interface Config { measure: keyof T } +interface Ref { dataset: DS, N> } +interface DS { + a(config: Config>): void; + b: Ref; +} +declare const x: DS<{ total: M }, string>; +export const y: DS, string> = x; diff --git a/tsc/testdata/tests/cases/compiler/recursiveVarianceFixedPoint.ts b/tsc/testdata/tests/cases/compiler/recursiveVarianceFixedPoint.ts new file mode 100755 index 0000000000000..3a26019b2db52 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/recursiveVarianceFixedPoint.ts @@ -0,0 +1,159 @@ +// @strict: true +// @target: es2015 +// @noEmit: true + +// @filename: storeFirst.ts +export {}; + +interface Store { + value: T; + listener: Listener; +} +type Listener = (batch: Store) => void; + +declare let strings: Store; +declare let unknowns: Store; +declare let stringListener: Listener; +declare let unknownListener: Listener; + +unknowns = strings; // Error +unknownListener = stringListener; // Error + +// @filename: listenerFirst.ts +export {}; + +type Listener = (batch: Store) => void; +interface Store { + listener: Listener; + value: T; +} + +declare let strings: Store; +declare let unknowns: Store; +declare let stringListener: Listener; +declare let unknownListener: Listener; + +unknownListener = stringListener; // Error +unknowns = strings; // Error + +// @filename: columnDefFirst.ts +export {}; + +interface ColumnDef { + cell?: (column: Column) => void; +} +interface Column { + accessorFn?: (row: Row) => Value; + columnDef: ColumnDef; +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; + +unknownColumn = stringColumn; // Error +stringColumn = unknownColumn; // Error + +// @filename: columnFirst.ts +export {}; + +interface Column { + columnDef: ColumnDef; + accessorFn?: (row: Row) => Value; +} +interface ColumnDef { + cell?: (column: Column) => void; +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; + +unknownColumn = stringColumn; // Error +stringColumn = unknownColumn; // Error + +// @filename: positiveRecursion.ts +export {}; + +interface Tree { + readonly value: T; + readonly children: readonly Tree[]; + readonly metadata: Map; +} +interface Phantom { + next: Phantom; +} + +declare let stringTree: Tree; +declare let unknownTree: Tree; +declare let stringPhantom: Phantom; +declare let numberPhantom: Phantom; + +unknownTree = stringTree; +stringTree = unknownTree; // Error +stringPhantom = numberPhantom; +numberPhantom = stringPhantom; + +// @filename: nestedComposition.ts +export {}; + +interface Outer { + value: T; + next: Inner>; +} +interface Inner { + consume: (value: T) => void; +} + +declare let strings: Outer; +declare let unknowns: Outer; + +unknowns = strings; // Error +strings = unknowns; // Error + +// @filename: annotations.ts +export {}; + +interface AnnotatedTree { + readonly value: T; + readonly children: AnnotatedTree[]; +} +interface AnnotatedStore { + value: T; + listener: (batch: AnnotatedStore) => void; +} + +declare let stringTree: AnnotatedTree; +declare let unknownTree: AnnotatedTree; +declare let stringStore: AnnotatedStore; +declare let unknownStore: AnnotatedStore; + +unknownTree = stringTree; +stringTree = unknownTree; // Error +unknownStore = stringStore; // Error +stringStore = unknownStore; // Error + +// @filename: structuralMeasurement.ts +export {}; + +interface GenericMethod { + value: T; + next: (value: U) => GenericMethod; +} +interface Projected { + value: T["value"]; + next: Projected; +} +interface Method { + value: T; + accept(value: Method): void; +} + +declare let strings: GenericMethod; +declare let unknowns: GenericMethod; +declare let stringMethod: Method; +declare let unknownMethod: Method; +declare let projected: Projected<{ value: string; extra: number }>; + +unknowns = strings; +strings = unknowns; // Error +unknownMethod = stringMethod; +const widened: Projected<{ value: string }> = projected; diff --git a/tsc/testdata/tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts b/tsc/testdata/tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts new file mode 100644 index 0000000000000..90d725f47d2e7 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts @@ -0,0 +1,10 @@ +// @strict: true +// @noEmit: true + +// Instantiating E := {} turns the type of v into unknown. Inferring +// K := never must not then turn it into {}['V'][never], which is never. +interface I { + f(k: K, v: E['V'][K]): void; +} +declare const i: I<{}>; +i.f("x" as never, 1); diff --git a/tsc/testdata/tests/cases/compiler/relationComplexityError.ts b/tsc/testdata/tests/cases/compiler/relationComplexityError.ts index 7b83dcf8dc6fd..ac2c6c2559ab7 100644 --- a/tsc/testdata/tests/cases/compiler/relationComplexityError.ts +++ b/tsc/testdata/tests/cases/compiler/relationComplexityError.ts @@ -1,17 +1,32 @@ -// @target: es2015 -// @strict: true -// @noEmit: true - -// Repro from #55630 - -type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; -type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; -type T2 = { a: string } | { b: number }; - -function f1(x: T1, y: T1 & T2) { - x = y; -} - -function f2(x: T1 | null, y: T1 & T2) { - x = y; // Complexity error -} +// @target: es2015 +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// Repro from #55630 +// Every comparison that needs a comparison that is too complex is too complex +// itself, whether or not that comparison happened before. + +type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; +type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; +type T2 = { a: string } | { b: number }; + +function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { + x = y; // Complexity error +} + +function f1(x: T1, y: T1 & T2) { + x = y; +} + +function f2(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error +} + +function f3(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error +} + +function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { + x = y; // Complexity error +} diff --git a/tsc/testdata/tests/cases/compiler/relationComplexitySharedCheckOrder.ts b/tsc/testdata/tests/cases/compiler/relationComplexitySharedCheckOrder.ts new file mode 100644 index 0000000000000..ab295001276e9 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/relationComplexitySharedCheckOrder.ts @@ -0,0 +1,26 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +type T1 = `${D}${D}${D}${D}` | undefined; +type T2 = { a: string } | { b: number }; +declare let x: T1 | null; +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +x = y1; +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +x = y2; +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +x = y3; +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +x = y4; +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +x = y5; +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +x = y6; +declare const y: T1 & T2; +x = y; diff --git a/tsc/testdata/tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts b/tsc/testdata/tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts new file mode 100644 index 0000000000000..6bcea78d38558 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts @@ -0,0 +1,98 @@ +// @strict: true +// @strictFunctionTypes: false +// @noEmit: true +// @checkOrder: default, typesfirst, editorfirst + +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = (x: T) => T["k"]; + type G = (x: A) => "c" | G | number; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = { m(x: T): T["k"] }; + type G = { m(x: A): "c" | G | number }; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { + type A1 = { k?: "c"; f: S2 | G2 }; + type C1 = { [s: string]: "c" | G2; f: G2 }; + type S1 = (x: T) => T["k"]; + type G1 = (x: A1) => "c" | G2; + type A2 = { k?: "d"; f: S1 | G1 }; + type C2 = { [s: string]: "d" | G1; f: G1 }; + type S2 = (x: T) => T["k"]; + type G2 = (x: A2) => "d" | G1; + + declare let s1: S1; + declare let s2: S2; + let g1: G1 = s1; + let g2: G2 = s2; + declare let r1: S1 extends G1 ? true : false; + declare let r2: S2 extends G2 ? true : false; +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + + declare let r1: Src extends Tgt ? true : false; + declare let r2: X extends Y ? true : false; +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; + + declare let src: Src; + let o: Outer = { e: src, w: 1 }; + declare let r2: X extends Y ? true : false; +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { + type P = { f: F | G; z: number }; + type Q = { f: G; z: 1 }; + type F = (x?: P) => 1; + type G = (x: Q | undefined) => number; + type WP = { a: P; b: string }; + type WQ = { a: Q }; + + declare let f: F, g: G, wp: WP, wq: WQ; + let a1 = [f, g]; + let a2 = [wp, wq]; +} diff --git a/tsc/testdata/tests/cases/compiler/relationDeeplyNestedCheckOrder.ts b/tsc/testdata/tests/cases/compiler/relationDeeplyNestedCheckOrder.ts new file mode 100644 index 0000000000000..638ea1b62008b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/relationDeeplyNestedCheckOrder.ts @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true + +// Relating 'B<{ a: string }>' to 'B<{ a: "lit" }>' eventually relates 'string' +// to '"lit"' through 'm0.m1.a.m0.m1', but only after measuring the variances +// of 'A', which gives up on deeply nested types. TypeScript reports an error +// for the 'B' assignment only when it is checked before the 'A' assignment; +// the result must not depend on which is checked first. + +type A = { m0: (x: B) => void; m1: { [K in keyof T]: B } }; +type B = { m0: A }; + +declare let a1: A<{ a: string }>, a2: A<{ a: "lit" }>; +declare let b1: B<{ a: string }>, b2: B<{ a: "lit" }>; + +a2 = a1; +b2 = b1; diff --git a/tsc/testdata/tests/cases/compiler/relationDepthSharedCheckOrder.ts b/tsc/testdata/tests/cases/compiler/relationDepthSharedCheckOrder.ts new file mode 100644 index 0000000000000..2f629c226fe3a --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/relationDepthSharedCheckOrder.ts @@ -0,0 +1,253 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +interface J0 { next: J1 } +interface I1 { next: I2 } +interface J1 { next: J2 } +interface I2 { next: I3 } +interface J2 { next: J3 } +interface I3 { next: I4 } +interface J3 { next: J4 } +interface I4 { next: I5 } +interface J4 { next: J5 } +interface I5 { next: I6 } +interface J5 { next: J6 } +interface I6 { next: I7 } +interface J6 { next: J7 } +interface I7 { next: I8 } +interface J7 { next: J8 } +interface I8 { next: I9 } +interface J8 { next: J9 } +interface I9 { next: I10 } +interface J9 { next: J10 } +interface I10 { next: I11 } +interface J10 { next: J11 } +interface I11 { next: I12 } +interface J11 { next: J12 } +interface I12 { next: I13 } +interface J12 { next: J13 } +interface I13 { next: I14 } +interface J13 { next: J14 } +interface I14 { next: I15 } +interface J14 { next: J15 } +interface I15 { next: I16 } +interface J15 { next: J16 } +interface I16 { next: I17 } +interface J16 { next: J17 } +interface I17 { next: I18 } +interface J17 { next: J18 } +interface I18 { next: I19 } +interface J18 { next: J19 } +interface I19 { next: I20 } +interface J19 { next: J20 } +interface I20 { next: I21 } +interface J20 { next: J21 } +interface I21 { next: I22 } +interface J21 { next: J22 } +interface I22 { next: I23 } +interface J22 { next: J23 } +interface I23 { next: I24 } +interface J23 { next: J24 } +interface I24 { next: I25 } +interface J24 { next: J25 } +interface I25 { next: I26 } +interface J25 { next: J26 } +interface I26 { next: I27 } +interface J26 { next: J27 } +interface I27 { next: I28 } +interface J27 { next: J28 } +interface I28 { next: I29 } +interface J28 { next: J29 } +interface I29 { next: I30 } +interface J29 { next: J30 } +interface I30 { next: I31 } +interface J30 { next: J31 } +interface I31 { next: I32 } +interface J31 { next: J32 } +interface I32 { next: I33 } +interface J32 { next: J33 } +interface I33 { next: I34 } +interface J33 { next: J34 } +interface I34 { next: I35 } +interface J34 { next: J35 } +interface I35 { next: I36 } +interface J35 { next: J36 } +interface I36 { next: I37 } +interface J36 { next: J37 } +interface I37 { next: I38 } +interface J37 { next: J38 } +interface I38 { next: I39 } +interface J38 { next: J39 } +interface I39 { next: I40 } +interface J39 { next: J40 } +interface I40 { next: I41 } +interface J40 { next: J41 } +interface I41 { next: I42 } +interface J41 { next: J42 } +interface I42 { next: I43 } +interface J42 { next: J43 } +interface I43 { next: I44 } +interface J43 { next: J44 } +interface I44 { next: I45 } +interface J44 { next: J45 } +interface I45 { next: I46 } +interface J45 { next: J46 } +interface I46 { next: I47 } +interface J46 { next: J47 } +interface I47 { next: I48 } +interface J47 { next: J48 } +interface I48 { next: I49 } +interface J48 { next: J49 } +interface I49 { next: I50 } +interface J49 { next: J50 } +interface I50 { next: I51 } +interface J50 { next: J51 } +interface I51 { next: I52 } +interface J51 { next: J52 } +interface I52 { next: I53 } +interface J52 { next: J53 } +interface I53 { next: I54 } +interface J53 { next: J54 } +interface I54 { next: I55 } +interface J54 { next: J55 } +interface I55 { next: I56 } +interface J55 { next: J56 } +interface I56 { next: I57 } +interface J56 { next: J57 } +interface I57 { next: I58 } +interface J57 { next: J58 } +interface I58 { next: I59 } +interface J58 { next: J59 } +interface I59 { next: I60 } +interface J59 { next: J60 } +interface I60 { next: I61 } +interface J60 { next: J61 } +interface I61 { next: I62 } +interface J61 { next: J62 } +interface I62 { next: I63 } +interface J62 { next: J63 } +interface I63 { next: I64 } +interface J63 { next: J64 } +interface I64 { next: I65 } +interface J64 { next: J65 } +interface I65 { next: I66 } +interface J65 { next: J66 } +interface I66 { next: I67 } +interface J66 { next: J67 } +interface I67 { next: I68 } +interface J67 { next: J68 } +interface I68 { next: I69 } +interface J68 { next: J69 } +interface I69 { next: I70 } +interface J69 { next: J70 } +interface I70 { next: I71 } +interface J70 { next: J71 } +interface I71 { next: I72 } +interface J71 { next: J72 } +interface I72 { next: I73 } +interface J72 { next: J73 } +interface I73 { next: I74 } +interface J73 { next: J74 } +interface I74 { next: I75 } +interface J74 { next: J75 } +interface I75 { next: I76 } +interface J75 { next: J76 } +interface I76 { next: I77 } +interface J76 { next: J77 } +interface I77 { next: I78 } +interface J77 { next: J78 } +interface I78 { next: I79 } +interface J78 { next: J79 } +interface I79 { next: I80 } +interface J79 { next: J80 } +interface I80 { next: I81 } +interface J80 { next: J81 } +interface I81 { next: I82 } +interface J81 { next: J82 } +interface I82 { next: I83 } +interface J82 { next: J83 } +interface I83 { next: I84 } +interface J83 { next: J84 } +interface I84 { next: I85 } +interface J84 { next: J85 } +interface I85 { next: I86 } +interface J85 { next: J86 } +interface I86 { next: I87 } +interface J86 { next: J87 } +interface I87 { next: I88 } +interface J87 { next: J88 } +interface I88 { next: I89 } +interface J88 { next: J89 } +interface I89 { next: I90 } +interface J89 { next: J90 } +interface I90 { next: I91 } +interface J90 { next: J91 } +interface I91 { next: I92 } +interface J91 { next: J92 } +interface I92 { next: I93 } +interface J92 { next: J93 } +interface I93 { next: I94 } +interface J93 { next: J94 } +interface I94 { next: I95 } +interface J94 { next: J95 } +interface I95 { next: I96 } +interface J95 { next: J96 } +interface I96 { next: I97 } +interface J96 { next: J97 } +interface I97 { next: I98 } +interface J97 { next: J98 } +interface I98 { next: I99 } +interface J98 { next: J99 } +interface I99 { next: I100 } +interface J99 { next: J100 } +interface I100 { next: I101 } +interface J100 { next: J101 } +interface I101 { next: I102 } +interface J101 { next: J102 } +interface I102 { next: I103 } +interface J102 { next: J103 } +interface I103 { next: I104 } +interface J103 { next: J104 } +interface I104 { next: I105 } +interface J104 { next: J105 } +interface I105 { next: I106 } +interface J105 { next: J106 } +interface I106 { next: I107 } +interface J106 { next: J107 } +interface I107 { next: I108 } +interface J107 { next: J108 } +interface I108 { next: I109 } +interface J108 { next: J109 } +interface I109 { next: I110 } +interface J109 { next: J110 } +interface I110 { next: I111 } +interface J110 { next: J111 } +interface I111 { next: I112 } +interface J111 { next: J112 } +interface I112 { next: I113 } +interface J112 { next: J113 } +interface I113 { next: I114 } +interface J113 { next: J114 } +interface I114 { next: I115 } +interface J114 { next: J115 } +interface I115 { next: I116 } +interface J115 { next: J116 } +interface I116 { next: I117 } +interface J116 { next: J117 } +interface I117 { next: I118 } +interface J117 { next: J118 } +interface I118 { next: I119 } +interface J118 { next: J119 } +interface I119 { leaf: string } +interface J119 { leaf: number } + +type Mid = I60 extends J60 ? true : false; +type All = I0 extends J0 ? true : false; diff --git a/tsc/testdata/tests/cases/compiler/relationMaybeCheckOrder.ts b/tsc/testdata/tests/cases/compiler/relationMaybeCheckOrder.ts new file mode 100644 index 0000000000000..b56c53b300a7a --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/relationMaybeCheckOrder.ts @@ -0,0 +1,24 @@ +// @strict: true +// @noEmit: true + +// Relating to 'keyof M' rejects keys that relate only by assuming a +// comparison still in progress. Relating 'A' to 'B' assumes only itself +// along 'next', so it completes on its own and must be accepted whether +// or not the call to 'h' related 'A' to 'B' first. + +interface A { next: A; v: "a" } +interface B { next: B; v: string } +type M = { [K in keyof T as B]: 1 }; + +declare const a: A; +declare function h(x: B): 1; +declare function h(x: unknown): 2; + +function f() { + function g(x: keyof M): 1; + function g(x: unknown): 2; + function g(x: unknown) { return 1 as any; } + const r: 1 = g(a); +} + +const w: 1 = h(a); diff --git a/tsc/testdata/tests/cases/compiler/relationNestingSharedCheckOrder.ts b/tsc/testdata/tests/cases/compiler/relationNestingSharedCheckOrder.ts new file mode 100644 index 0000000000000..b92d749878450 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/relationNestingSharedCheckOrder.ts @@ -0,0 +1,15 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +type R = { next: R<[T]>; leaf: T }; + +type Inner = S<[string]> extends R<[string]> ? true : false; +type Outer = S extends R ? true : false; diff --git a/tsc/testdata/tests/cases/compiler/relationTruncatedCacheCheckOrder.ts b/tsc/testdata/tests/cases/compiler/relationTruncatedCacheCheckOrder.ts new file mode 100644 index 0000000000000..1332ce5a04d59 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/relationTruncatedCacheCheckOrder.ts @@ -0,0 +1,18 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' +// before giving up on deeply nested types, and fails there. Inside the +// relation of 'S' to 'R' it is one level deeper and is cut +// short instead. That truncated result must not be cached, so the error for +// 'q = p' must be reported whether or not 'y = x' was checked first. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +type R = { next: R<[T]>; leaf: T }; + +declare let x: S, y: R; +declare let p: S<[string]>, q: R<[string]>; + +y = x; +q = p; diff --git a/tsc/testdata/tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts b/tsc/testdata/tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts new file mode 100644 index 0000000000000..7d06216a59546 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts @@ -0,0 +1,183 @@ +// @strict: true +// @exactOptionalPropertyTypes: true +// @module: nodenext +// @target: esnext +// @noEmit: true +// @skipLibCheck: true + +// @filename: arraySlice.d.ts +export type {ArraySlice}; +declare const tag: unique symbol; +type IsNever = [T] extends [never] ? true : false; +type IsEqual = + [A] extends [B] + ? [B] extends [A] + ? _IsEqual + : false + : false; +type _IsEqual = never; +type Primitive = + | null + | undefined + | string + | number + | boolean + | symbol + | bigint; +type UnknownArray = any; +type IfNotAnyOrNever = + IsNever extends true + ? 'ifNever' extends keyof Cases + ? Cases['ifNever'] + : never + : Cases['ifNot']; +type And = B; +type Not = any; +type MaxLength = never; +type HasNoStaticElements = unknown; +type CollapseLiterals = Union extends Primitive + ? Union extends infer Collapsed & {} + ? Collapsed + : Union + : Union; +type PositiveNumericStringGt = A; +type Absolute = _Absolute : N>; +type _Absolute = N extends bigint + ? `${N}` extends `-${infer Magnitude extends bigint}` + ? Magnitude + : N + : `${N}` extends `-${infer Magnitude extends number}` + ? Magnitude + : `${N}` extends '-Infinity' + ? PositiveInfinity + : `${number}` extends `${N}` ? number : N; +type GreaterThan = + _GreaterThan : A, B extends object ? UnwrapBrand : B>; +type _GreaterThan = + A extends _Numeric + ? B extends _Numeric + ? `${number}` extends `${A | B}` + ? boolean + : bigint extends A | B + ? boolean + : A extends PositiveInfinity + ? B extends PositiveInfinity ? false : true + : B extends NegativeInfinity + ? A extends NegativeInfinity ? false : true + : A extends NegativeInfinity + ? false + : B extends PositiveInfinity + ? false + : [IsNegative, IsNegative] extends infer Signs extends [boolean, boolean] + ? [true, false] extends Signs + ? false + : [false, true] extends Signs + ? true + : [false, false] extends Signs + ? PositiveNumericStringGt<`${A}`, `${B}`> + : PositiveNumericStringGt<`${Absolute}`, `${Absolute}`> + : never + : never + : never; +type IsReadonlyArray = never; +type UnionMember = + IsNever extends true + ? never + : (T extends any ? () => T : never) extends () => (infer R) + ? R + : never; +type TagContainer = { + readonly [tag]: Token; +}; +type Tag = unknown; +type RemoveAllTags = T extends TagContainer + ? RemoveAllTags>> + : T; +type RemoveTag> = + | { + [ThisTag in keyof T[typeof tag]]: T extends infer Underlying & Tag + ? [Underlying] extends [T] ? never : Underlying + : never + }[keyof T[typeof tag]] + | (T extends infer Underlying & TagContainer + ? [Underlying] extends [T] ? never : Underlying + : never); +type UnwrapBrand = IfNotAnyOrNever}>; +type _UnwrapBrand = T extends Primitive + ? CollapseLiterals ? RemoveAllTags : T> + : T; +type _Numeric = number | bigint; +type PositiveInfinity = unknown; +type NegativeInfinity = never; +type IsNegative = never; +type Sum = any; +type LessThanOrEqual = unknown; +type ArraySlice< + Array_ extends readonly unknown[], + Start extends number = never, + End extends number = never, +> = ArraySliceImplementation : Start, End>; +type ArraySliceImplementation< + Array_ extends readonly unknown[], + Start extends number, + End extends number, +> = Array_ extends unknown ? _ArraySlice : never; +type _ArraySlice< + Array_ extends readonly unknown[], + Start extends number = 0, + End extends number = Array_['length'], +> = And, IsEqual> extends true + ? Array_ + : number extends Array_['length'] + ? VariableLengthArraySliceHelper extends true ? 0 : Start, End extends PositiveInfinity ? never : End> + : `${number}` extends `${Start | End}` + ? UnknownLengthArraySlice + : ArraySliceResult extends true ? 0 : Start, IsEqual extends true ? MaxLength : End>>; +type ArraySliceResult = + IsReadonlyArray extends true ? Readonly : Sliced; +type VariableLengthArraySliceHelper< + Array_ extends readonly unknown[], + Start extends number, + End extends number, +> = And< + And>, Not>>, + IsEqual, true> +> extends true + ? [] + : And< + And>, Not>>, + IsEqual, true> + > extends true + ? HasNoStaticElements extends true + ? UnknownLengthArraySlice + : ArraySliceResult> + : UnknownLengthArraySlice; +type UnknownLengthArraySlice = any; +type ArraySliceHelper< + Array_ extends readonly unknown[], + Start extends number = 0, + End extends number = MaxLength, + ArrayLength extends number = MaxLength, +> = never; +type ArraySliceByPositiveIndex< + Array_ extends readonly unknown[], + Start extends number, + End extends number, + Result extends Array = [], +> = Start extends End + ? Result + : ArraySliceByPositiveIndex, End, [...Result, Array_[Start]]>; + +// @filename: main.ts +// Reduced from type-fest's ArraySlice. Inferring Value from the argument +// measures the variances of ArraySlice, which takes the restrictive +// instantiations of conditional types whose type parameters are already +// restrictive, many times over through the brand-unwrapping types. Such an +// instantiation must be the conditional type itself: making and evaluating +// a separate copy roughly triples the work, enough to exceed the +// instantiation count limit (TS2589) here. Smaller cases do not get near +// the limit either way, so the case is as large as the limit requires. +import type {ArraySlice} from './arraySlice.d.ts'; +declare function f(values: ArraySlice): void; +declare const x: ArraySlice; +f(x); diff --git a/tsc/testdata/tests/cases/compiler/returnTypeInferenceNotTooBroad.ts b/tsc/testdata/tests/cases/compiler/returnTypeInferenceNotTooBroad.ts index fb987440a546e..72c12f9dd0af5 100644 --- a/tsc/testdata/tests/cases/compiler/returnTypeInferenceNotTooBroad.ts +++ b/tsc/testdata/tests/cases/compiler/returnTypeInferenceNotTooBroad.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; interface Opts { diff --git a/tsc/testdata/tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts b/tsc/testdata/tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts index 71209527ff35b..0d51e874d2db2 100644 --- a/tsc/testdata/tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts +++ b/tsc/testdata/tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts @@ -1,5 +1,6 @@ // @strict: true // @noEmit: true +// @checkOrder: default, typesfirst interface A { kind: string; m: this["kind"] } interface B { m: "a" } diff --git a/tsc/testdata/tests/cases/compiler/signatureHelpInferenceQueryOrder.ts b/tsc/testdata/tests/cases/compiler/signatureHelpInferenceQueryOrder.ts new file mode 100644 index 0000000000000..dbec9354b5994 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/signatureHelpInferenceQueryOrder.ts @@ -0,0 +1,11 @@ +// @target: es2015 +// @strict: false +// @checkOrder: default,editorfirst + +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +interface A { a: A; } +interface B extends A { b; } + +declare var a: A, b: B; + +var d = f(a, b, x => x, x => x); diff --git a/tsc/testdata/tests/cases/compiler/substitutionInDeferredConditionalOfConditional.ts b/tsc/testdata/tests/cases/compiler/substitutionInDeferredConditionalOfConditional.ts new file mode 100644 index 0000000000000..689b6d3da6017 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/substitutionInDeferredConditionalOfConditional.ts @@ -0,0 +1,24 @@ +// @strict: true +// @noEmit: true + +// Children always produces a Record, so it satisfies NeedsRecord. Its +// true branch narrows S["states"] to Record even when S is +// a conditional type that is itself deferred. + +interface Schema { + states?: Record; +} +type Resolve, Segments extends readonly string[]> = + Segments extends [infer Head extends string, ...infer Rest extends string[]] + ? Head extends keyof S + ? Rest extends [] + ? S[Head] + : S[Head]["states"] extends Record + ? Resolve + : never + : never + : never; +type Split

= P extends `${infer Head}.${infer Tail}` ? [Head, Tail] : [P]; +type Children = S["states"] extends Record ? S["states"] : Record; +type NeedsRecord> = T; +type ChildrenAt, P extends string> = NeedsRecord>>>; diff --git a/tsc/testdata/tests/cases/compiler/templateLiteralTypeExcessiveLength.ts b/tsc/testdata/tests/cases/compiler/templateLiteralTypeExcessiveLength.ts index eeb573c01c164..77d5e59654843 100644 --- a/tsc/testdata/tests/cases/compiler/templateLiteralTypeExcessiveLength.ts +++ b/tsc/testdata/tests/cases/compiler/templateLiteralTypeExcessiveLength.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @strict: true // Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and diff --git a/tsc/testdata/tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts b/tsc/testdata/tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts new file mode 100644 index 0000000000000..f2f483ff8ee6f --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts @@ -0,0 +1,25 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// The default of T applies to the call inside the callback passed to another +// generic function as it does elsewhere, so data is accepted. + +declare function fetcher(cfg: unknown): Promise; + +type Routes = R extends 'x' ? { IN: { v: number }, OUT: string } : never; + +function executeFetch>( + route: R, + body?: T extends Record<'IN', any> ? T['IN'] : never +) { + return fetcher ? T['OUT'] : T>({ route, body }); +} + +declare function useCallback(cb: T, deps: unknown[]): T; + +export const cb = useCallback((data: { v: number }) => { + return executeFetch('x', data); +}, []); + +export const check: Promise = cb({ v: 1 }); diff --git a/tsc/testdata/tests/cases/compiler/typeParameterHasSelfAsConstraint.ts b/tsc/testdata/tests/cases/compiler/typeParameterHasSelfAsConstraint.ts index 3b2267f54389c..9c99dcb98fa60 100644 --- a/tsc/testdata/tests/cases/compiler/typeParameterHasSelfAsConstraint.ts +++ b/tsc/testdata/tests/cases/compiler/typeParameterHasSelfAsConstraint.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 function foo(x: T): number { return x; diff --git a/tsc/testdata/tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts b/tsc/testdata/tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts new file mode 100644 index 0000000000000..5de9a46c5bc90 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts @@ -0,0 +1,16 @@ +// @noEmit: true +// @target: esnext +// @checkOrder: default, typesfirst + +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { + slice(): B; + every(predicate: (value: T) => value is S): this is A; + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +} +interface B extends A {} +const a: A<0> = []; +const b: B<0> = []; diff --git a/tsc/testdata/tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts b/tsc/testdata/tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts index 6a4517411287d..d834c23767f8f 100644 --- a/tsc/testdata/tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts +++ b/tsc/testdata/tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 //@noUnusedLocals:true //@noUnusedParameters:true diff --git a/tsc/testdata/tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts b/tsc/testdata/tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts new file mode 100644 index 0000000000000..c946a4bdadd7b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts @@ -0,0 +1,22 @@ +// @strict: true +// @noUnusedLocals: true +// @target: es2022 +// @noEmit: true + +// Checking the call resolves it within a cycle of flow analysis, during which +// what checking computes is recorded, yet its references are still uses. + +declare const assert: { deepStrictEqual(actual: unknown, expected: T): asserts actual is T }; +declare function make(): { width: number }; +export function test() { + const first = make(); + let baseline: number[][] | undefined; + const geometry = () => [first].map(e => [e.width]); + for (const themeType of ['a', 'b']) { + baseline ??= geometry(); + for (const active of [true, false]) { + const border = active ? themeType : 'x'; + assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }); + } + } +} diff --git a/tsc/testdata/tests/cases/compiler/unusedTypeParameterQueryOrder.ts b/tsc/testdata/tests/cases/compiler/unusedTypeParameterQueryOrder.ts new file mode 100644 index 0000000000000..f9fa662fe35d9 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/unusedTypeParameterQueryOrder.ts @@ -0,0 +1,10 @@ +// @target: es2015 +// @noUnusedLocals: true +// @noUnusedParameters: true +// @checkOrder: default,editorfirst + +class A { + f() { + return () => {}; + } +} diff --git a/tsc/testdata/tests/cases/compiler/varianceCircularConsistency.ts b/tsc/testdata/tests/cases/compiler/varianceCircularConsistency.ts new file mode 100644 index 0000000000000..c6c3ccb148802 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCircularConsistency.ts @@ -0,0 +1,29 @@ +// @strict: true +// @noEmit: true + +// Variances of these mutually recursive generics must not depend on values +// measured mid-cycle. Assigning `e` to `EntryPoint` must agree with +// assigning `e.root` to `EntryPoint["root"]`. + +interface Query {} +type Component

= P | ((props: P) => void); +interface Ref { + value: T; +} +interface Rep, Nested, Runtime, Extra> extends Readonly<{ + root: Ref>; +}> {} +type Preloaded = T extends Record> ? { [K in keyof T]: Unwrap> } : never; +interface Props extends Readonly<{ + nested: Preloaded; + queries: Queries; +}> {} +type EntryPointComponent, Nested, Runtime, Extra = {}> = Component>; +type Unwrap = C extends EntryPointComponent ? Readonly<{}> : {}; +type EntryPoint = Rep ? Q : never, never, never, never>; +type GetComponent = T extends EntryPoint ? C : never; + +declare const c: EntryPointComponent<{ q: { readonly variables: { slug: string } } }, {}, { onClick: () => void }>; +declare const e: EntryPoint; +const whole: EntryPoint = e; +const root: EntryPoint["root"] = e.root; diff --git a/tsc/testdata/tests/cases/compiler/varianceCircularityEnteredByInference.ts b/tsc/testdata/tests/cases/compiler/varianceCircularityEnteredByInference.ts new file mode 100644 index 0000000000000..69be126dcaf14 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCircularityEnteredByInference.ts @@ -0,0 +1,51 @@ +// @strict: true +// @target: esnext +// @noEmit: true +// @checkOrder: default,typesfirst + +// AstObject and AstValue form a variance circularity. AstValue is covariant +// in T through typeBrand, and AstObject reaches it through getValue, so +// AstObject is not assignable to AstObject and the +// call below must be an error. Checking getValue first infers the type +// arguments of `new AstValue` from its return type, which measures AstValue +// first; AstObject, measured inside it, then sees T only in references to +// the types in progress, and main recorded it as independent of T and +// accepted the call. Main reports the error when AstObject's variance is +// measured first. + +export {}; + +type ObjectType = T extends object ? T : never; + +class AstObject { + constructor(private host: E) {} + + getObject(key: K): AstObject, E> { + return new AstObject, E>(this.host); + } + + getValue(key: K): AstValue { + return new AstValue(this.host); + } +} + +class AstValue { + declare typeBrand: T; + + constructor(private host: E) {} + + getObject(): AstObject, E> { + return new AstObject(this.host); + } +} + +interface Empty {} +interface WithDecorators { + decorators: string; +} + +declare function useDerived(obj: AstObject): void; + +function useBase(obj: AstObject) { + useDerived(obj); +} diff --git a/tsc/testdata/tests/cases/compiler/varianceCircularityHidesInvariance.ts b/tsc/testdata/tests/cases/compiler/varianceCircularityHidesInvariance.ts new file mode 100644 index 0000000000000..b76009f354e84 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCircularityHidesInvariance.ts @@ -0,0 +1,74 @@ +// @strict: true +// @target: esnext +// @noEmit: true +// @checkOrder: default,typesfirst + +// Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and +// ScriptableContext form a variance circularity. ScriptableContext is in +// fact invariant: ScriptableContext<"bar" | "line"> is not assignable to +// ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not +// assignable to Chart and the assignment below must be an error. +// Measuring variances from the circularity's entry, main recorded +// ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and +// accepted it; main reports this error too when ScriptableContext's variance +// is measured first (e.g. after checking a ScriptableContext assignment). + +declare class Element { options: O } +type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined +type _DeepPartialObject = { [P in keyof T]?: DeepPartial } +type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never +type AnyObject = Record +interface ScriptableContext { + dataset: UnionToIntersection> +} +type Scriptable = (ctx: TContext) => T +declare class Chart { + config: ChartConfigurationCustomTypesPerDataset +} +interface Plugin { + id: string; + beforeDraw(chart: Chart): void +} +interface CoreChartOptions { + backgroundColor: Scriptable> +} +interface AnimationSpec { + delay: Scriptable> +} +interface TooltipModel extends Element> { + chart: Chart +} +interface TooltipDatasetCallbacks> { + (this: Model): void +} +interface TooltipOptions { + animation: AnimationSpec +} +interface TooltipDatasetOptions { + callbacks: TooltipDatasetCallbacks +} +interface PluginDatasetOptionsByType { + tooltip: TooltipDatasetOptions +} +interface ChartTypeRegistry { + bar: { defaultDataPoint: [] } + line: { defaultDataPoint: null } +} +type ChartType = keyof ChartTypeRegistry +type DatasetChartOptions = { [key in TType]: {} } +type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> +interface ChartDatasetProperties { + data: TData +} +type ChartDataset = + DeepPartial> & ChartDatasetProperties +type ChartDatasetCustomTypesPerDataset = DeepPartial> +interface ChartDataCustomTypesPerDataset { + datasets: ChartDatasetCustomTypesPerDataset +} +export interface ChartConfigurationCustomTypesPerDataset { + data: ChartDataCustomTypesPerDataset + options: ChartOptions +} + +const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleCachedResults.ts b/tsc/testdata/tests/cases/compiler/varianceCycleCachedResults.ts new file mode 100644 index 0000000000000..935dada6a890f --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleCachedResults.ts @@ -0,0 +1,25 @@ +// @strict: true + +// Relating 'Box' to 'Box' measures the variances of 'Box', which +// resolves the return type of 'm', which relates 'Box' to 'Box' +// while those variances are incomplete, reducing the union to 'Box'. +// Resolving 'm' first measures the variances of 'Box' and resolves 'm' again +// inside, the same way, so 'm' returns 'Box' whichever is first. + +// @filename: first.ts +declare let b1: Box; +declare let b2: Box; +b1 = b2; + +// @filename: box.ts +declare let a1: Box; +declare let a2: Box; +declare const cond: boolean; +class Box { + value!: T; + m() { + if (cond) return a1; + return a2; + } +} +const r = new Box().m(); diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleCapnwebRpcStub.ts b/tsc/testdata/tests/cases/compiler/varianceCycleCapnwebRpcStub.ts new file mode 100644 index 0000000000000..990358f14d3ee --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleCapnwebRpcStub.ts @@ -0,0 +1,170 @@ +// @strict: true +// @target: esnext +// @lib: esnext,dom +// @skipLibCheck: true +// @noEmit: true + +// The RpcStub types of capnweb 0.12.0 (MIT license, Copyright (c) 2025 +// Cloudflare, Inc.), as used by cloudflare-os. Stub, Result, MethodOrProperty, +// MaybeCallableProvider and others form a variance circularity in which the +// types measured before it completes are measured unreliable. Comparisons +// of them while it completes must not fall back to comparing structurally, +// or measuring it reaches the instantiation limit (TS2589), and the `.then` +// callback parameter is implicitly any (TS7006). + +// @filename: capnweb.d.ts +// Copyright (c) 2025 Cloudflare, Inc. +// Licensed under the MIT license found in the LICENSE.txt file or at: +// https://opensource.org/license/mit +// This file borrows heavily from `types/defines/rpc.d.ts` in workerd. +// Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s. +// TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`. +// For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to +// accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape) +declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND'; +declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND'; +// Distinguishes mapper placeholders from regular values so param unwrapping can accept them. +declare const __RPC_MAP_VALUE_BRAND: unique symbol; +interface RpcTargetBranded { + [__RPC_TARGET_BRAND]: never; +} +// Types that can be used through `Stub`s +// `never[]` preserves compatibility with strongly-typed function signatures without introducing +// `any` into inference. +type Stubable = RpcTargetBranded | ((...args: never[]) => unknown); +// Note: also true for `any` (call sites that care check `IsAny` first). +type IsUnknown = unknown extends T ? true : false; // Types that can be passed over RPC +// The reason for using a generic type here is to build the serializable subset of RPC-compatible +// composite types. This allows types defined with the "interface" keyword to pass the +// serializable check as well. Otherwise, only types defined with the "type" keyword would pass. +type RpcCompatible = // Allow `unknown` as a leaf so records/interfaces with `unknown` fields remain compatible. +(IsUnknown extends true ? unknown : never) // RPC-compatible base values +| BaseType // RPC-compatible composites +| Map ? RpcCompatible : never, T extends Map ? RpcCompatible : never> | Set ? RpcCompatible : never> | Array ? RpcCompatible : never> | ReadonlyArray ? RpcCompatible : never> | { [K in keyof T as K extends string | number ? K : never]: RpcCompatible } | Promise ? RpcCompatible : never> // Special types +| Stub // Serialized as stubs, see `Stubify` +| Stubable; +// Base type for all RPC stubs, including common memory management methods. +// `T` is used as a marker type for unwrapping `Stub`s later. +interface StubBase extends Disposable { + [__RPC_STUB_BRAND]: T; + dup(): this; + onRpcBroken(callback: (error: any) => void): void; +} +type Stub> = T extends object ? Provider & StubBase : StubBase; +type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array; // This represents all the types that can be sent as-is over an RPC boundary +type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | Blob | ReadableStream // Chunk type can be any RPC-compatible type +| WritableStream // Chunk type can be any RPC-compatible type +| URL | Request | Response | Headers; // Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises. +// Arm ordering matters here: +// - `Promise` must come before `StubBase`: `RpcPromise` matches both, and must resolve +// through the Promise arm rather than pass through as-is. +// - `StubBase` must come before `Stubable`: `Stub` of a callable `T` is itself callable, so +// it matches `Stubable`. Checking `StubBase` first keeps existing stubs as-is instead of +// double-wrapping them as `Stub>`. +// prettier-ignore +type Stubify = T extends Promise ? Stubify : T extends StubBase ? T : T extends Stubable ? Stub : T extends Map ? Map, Stubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Stubify, ...Stubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Stubify, ...Stubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T // When using "unknown" instead of "any", interfaces are not stubified. +: T extends { + [key: string | number]: any; +} ? { [K in keyof T as K extends string | number ? K : never]: Stubify } : T; +// Recursively rewrite all `Stub`s with the corresponding `T`s. +// Note we use `StubBase` instead of `Stub` here to avoid circular dependencies: +// `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`. +// prettier-ignore +type UnstubifyInner = // Preserve local RpcTarget acceptance, but avoid needless `Stub | Value` unions when the stub +// is already assignable to the value type (important for callback contextual typing). +T extends StubBase ? (T extends V ? UnstubifyInner : (T | UnstubifyInner)) : T extends Promise ? UnstubifyInner : T extends Map ? Map, Unstubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Unstubify, ...Unstubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Unstubify, ...Unstubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T : T extends { + [key: string | number]: unknown; +} ? { [K in keyof T as K extends string | number ? K : never]: Unstubify } : T; // You can put promises anywhere in the params and they'll be resolved before delivery. +// (This also covers RpcPromise, because it's defined as being a Promise.) +// Map placeholders are also allowed so primitive map callback inputs can be forwarded directly +// into RPC params. +// +// Keep raw non-stub members so generic assignability still works when UnstubifyInner is deferred. +// Remove stub members from mixed unions so callback params don’t get both stub and unstubbed signatures. +// Marker carried by map() callback inputs. This lets primitive placeholders flow through params. +type Unstubify = NonStubMembers | UnstubifyInner | Promise> | MapValuePlaceholder>; +type UnstubifyAll = { [I in keyof A]: Unstubify }; +interface MapValuePlaceholder { + [__RPC_MAP_VALUE_BRAND]: T; +} +type NonStubMembers = Exclude>; // Utility type for adding `Disposable`s to `object` types only. +// Note `unknown & T` is equivalent to `T`. +type MaybeDisposable = T extends object ? Disposable : unknown; // The type behind the public `RpcPromise` (re-exported with its `RpcCompatible` constraint from +// index.ts). Defined here so that `Result`'s arms below resolve to the exact same alias +// instantiation: when both sides of an assignability check are the same alias applied to the +// same type arguments, the checker short-circuits on identity instead of recursing through the +// full structural comparison of these mutually-recursive types. +type RpcPromise$1 = T extends Stubable ? Promise> & Provider & StubBase : Promise & MaybeDisposable> & Provider & StubBase; +// The elision `Result` applies to a bare stub type: unwrap `Stub` back to `T` when the +// payload is `Stubable`. Such stubs await back to a stub either way, so eliding keeps a +// declared `Promise>` return interchangeable with a `Promise` return. +// Plain-interface stubs are NOT elided: `RpcPromise` only awaits to `Stub` when +// `U extends Stubable`, so eliding those would change the awaited type from a stub to a +// stubified record. The payload check is deliberately non-distributive (`[U] extends [...]`). +// `Stub` is not elided either: `[any] extends [Stubable]` is true, so without the `IsAny` +// guard an `any`-payload stub would lose its stub surface. +// Also used by the `RpcPromise` constructor signature (index.ts), which applies exactly this +// transformation so constructing from a promised stub matches the method-return type. +type ElideStub = T extends StubBase ? (IsAny extends true ? T : [U] extends [Stubable] ? U : T) : T; +// What the promise given to `new RpcPromise(...)` may resolve to: the payload itself, or — +// for stubable payloads — a stub of it. `NoInfer` keeps the stub arm out of inference, so an +// inferred `T` is always the promise's own resolution type; the arm only matters when `T` is +// explicitly annotated (`new RpcPromise(promiseOfStub)`). Stubs of non-stubable +// payloads are deliberately rejected: `ElideStub` wouldn't elide those, so accepting one would +// claim the promise awaits to a stubified record while the runtime resolves to a stub. +type PayloadOrStub = T | NoInfer>>; +// Type for method return or property on an RPC interface. +// - Stubable types are replaced by stubs. +// - RpcCompatible types are passed by value, with stubable types replaced by stubs +// and a top-level `Disposer`. +// Everything else can't be passed over RPC. +// Technically, we use custom thenables here, but they quack like `Promise`s. +// Intersecting with `(Maybe)Provider` allows pipelining. +// prettier-ignore +type Result = IsAny extends true ? RpcPromise$1 // `RpcPromise`: always safe to normalize — `Result` is idempotent — so a declared +// `RpcPromise` return produces the same type as a `Promise` return. +: R extends PromiseLike & StubBase ? Result // Bare stubs: elide per `ElideStub` above. Note there is no `RpcCompatible` re-check +// here: anything matching our `StubBase` was produced by machinery that already enforced +// the constraint, and re-evaluating `RpcCompatible` in this arm recurses through its +// `Stub` member back into `Result`, tripping TS2615 circularity errors in mapped +// types. +: R extends StubBase ? RpcPromise$1> : R extends RpcCompatible ? RpcPromise$1 : never; +type IsAny = 0 extends (1 & T) ? true : false; // Type for method or property on an RPC interface. +// For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s. +// Unwrapping `Stub`s allows calling with `Stubable` arguments. +// For properties, rewrite types to be `Result`s. +// In each case, unwrap `Promise`s. +type MethodOrProperty = V extends ((...args: infer P) => infer R) ? (...args: UnstubifyAll

) => Result> : Result>; // Type for the callable part of an `Provider` if `T` is callable. +// This is intersected with methods/properties. +type MaybeCallableProvider = T extends ((...args: any[]) => any) ? MethodOrProperty : unknown; +type TupleIndexKeys> = Extract; +type MapCallbackValue = // `Omit` removes call signatures, so re-intersect callable provider behavior. +T extends unknown ? Omit, keyof Promise> & MaybeCallableProvider & MapValuePlaceholder : never; +type InvalidNativePromiseInMapResult = T extends unknown ? InvalidNativePromiseInMapResultImpl : never; +type InvalidNativePromiseInMapResultImpl = [T] extends [Seen] ? never // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values. +: T extends StubBase ? never // Native thenables cannot be represented in map recordings, even when typed as PromiseLike. +: T extends PromiseLike ? T : T extends Map ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends Set ? InvalidNativePromiseInMapResult : T extends readonly [] ? never : T extends readonly [infer Head, ...infer Tail] ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends ReadonlyArray ? InvalidNativePromiseInMapResult : T extends { + [key: string | number]: unknown; +} ? InvalidNativePromiseInMapResult], Seen | T> : never; +type MapCallbackReturn = InvalidNativePromiseInMapResult extends never ? T : never; +type ArrayProvider = { [K in number]: MethodOrProperty } & { + map(callback: (elem: MapCallbackValue) => MapCallbackReturn): Result>; +}; +type TupleProvider> = { [K in TupleIndexKeys]: MethodOrProperty } & ArrayProvider; // Base type for all other types providing RPC-like interfaces. +// Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types. +// `__RPC_TARGET_BRAND` deliberately flows through the key mapping (as a `never` property) so +// stubs of branded targets stay assignable to workers-types' `Stubable`. Such stubs match our +// `Stubable` too — harmless, since all machinery checks `StubBase` before `Stubable`. +type Provider = MaybeCallableProvider & (T extends ReadonlyArray ? number extends T["length"] ? ArrayProvider : TupleProvider : { [K in Exclude>]: MethodOrProperty } & { + map(callback: (value: MapCallbackValue>) => MapCallbackReturn): Result>; +}); +export type RpcStub> = Stub; + +// @filename: main.ts +import type { RpcStub } from "./capnweb"; + +declare const api: RpcStub<{ sub(): Promise> }>; +export async function f() { + await api.sub(); + api.sub().then(s => s); +} diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts b/tsc/testdata/tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts new file mode 100644 index 0000000000000..9b61b16136fc2 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts @@ -0,0 +1,28 @@ +// @strict: true +// @target: es2022 +// @noEmit: true + +// Measuring the variances of Bar resolves the type of Value, which picks an +// overload by relating Foo to Foo while the variances of Bar are +// still being measured. Diagnostics from that attempt must not outlive it, +// and the result must not depend on whether Value or the variances of Bar +// are needed first. + +interface A { a: string } +interface B { foo: string } +declare function pick(x: Foo): A; +declare function pick(x: object): B; + +class Bar { + x!: T; + Value = pick(new Foo(this)).foo; +} + +class Foo { + bar!: Bar; + constructor(bar: Bar) { + this.bar = bar; + } +} + +const v: number = new Bar().Value; diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts b/tsc/testdata/tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts new file mode 100644 index 0000000000000..6ac9f01d74269 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts @@ -0,0 +1,32 @@ +// @strict: true +// @target: esnext +// @noEmit: true +// @checkOrder: default,typesfirst + +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { + brand: T; +} +type Stub = T extends object ? Provider & StubBase : StubBase; +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +type RpcPromise = Promise> & Provider & StubBase; +type Result = R extends StubBase ? Result : RpcPromise; +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +type Provider = { [K in keyof T]: MethodOrProperty }; + +function f(x: Stubify, y: Stubify) { + y = x; + x = y; +} + +declare const api: Stub<{ sub(): Promise> }>; +export async function g() { + await api.sub(); + api.sub().then(s => s); +} diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleEntryOrder.ts b/tsc/testdata/tests/cases/compiler/varianceCycleEntryOrder.ts new file mode 100644 index 0000000000000..e7d881c167dcf --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleEntryOrder.ts @@ -0,0 +1,32 @@ +// @strict: true +// @noEmit: true + +// Foo and Bar are both invariant: Foo through x and the contravariant +// use of Foo in Bar, and Bar through f and the invariant Foo>. +// Their variances should not depend on which is measured first. + +// @filename: fooFirst.ts +export {}; + +interface Foo { x: T; b: Bar> } +interface Bar { f: (u: U) => void; foo: Foo> } + +declare let fs: Foo, fl: Foo<"lit">; +declare let bs: Bar, bl: Bar<"lit">; +fl = fs; // Error +fs = fl; // Error +bl = bs; // Error +bs = bl; // Error + +// @filename: barFirst.ts +export {}; + +interface Foo { x: T; b: Bar> } +interface Bar { f: (u: U) => void; foo: Foo> } + +declare let fs: Foo, fl: Foo<"lit">; +declare let bs: Bar, bl: Bar<"lit">; +bl = bs; // Error +bs = bl; // Error +fl = fs; // Error +fs = fl; // Error diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts b/tsc/testdata/tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts new file mode 100644 index 0000000000000..201c3c562d110 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts @@ -0,0 +1,312 @@ +// @strict: true +// @module: node16 +// @noEmit: true + +// The types of DefinitelyTyped's json-logic-js (MIT license). Measuring the +// variances of the RulesLogic circularity again from its canonical entry +// re-enters measurements whose own circularities may still be discarded, so +// what is cached while it is re-entered must be logged, or a discarded +// measurement leaves results behind and `apply` rejects its argument. + +// @filename: json-logic-js.d.ts +export as namespace jsonFactory; + +// Disable auto-export +export {}; + +type RenameToIn = { + [K in keyof T as K extends `in${Uppercase}${Lowercase}` ? `in` : K]: T[K]; +}; + +/** + * This is a utility type used below for the "if" operation. + * Original: https://stackoverflow.com/a/68373774/765987 + */ +type MAXIMUM_ALLOWED_BOUNDARY = 80; +type Mapped< + Tuple extends unknown[], + Result extends unknown[] = [], + Count extends readonly number[] = [], +> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result + : Tuple extends [] ? [] + : Result extends [] ? Mapped + : Mapped; +/** + * Used for the "if" operation, which takes an array of odd length + * and a minimum of three (3) elements. + */ +type AnyArrayOfOddLengthMin3 = [any, ...Mapped<[any, any]>]; + +export type ReservedOperations = + | "var" + | "missing" + | "missing_some" + | "if" + | "==" + | "===" + | "!=" + | "!==" + | "!" + | "!!" + | "or" + | "and" + | ">" + | ">=" + | "<" + | "<=" + | "max" + | "min" + | "+" + | "-" + | "*" + | "/" + | "%" + | "map" + | "filter" + | "reduce" + | "all" + | "none" + | "some" + | "merge" + | "in" + | "cat" + | "substr" + | "log"; + +/** + * This can be an object with any key except the reserved keys. + * TODO: Find a way to limit this type to exactly one (1) key, since + * json-logic-js enforces it. See: + * https://github.com/jwadhams/json-logic-js/blob/2.0.2/logic.js#L180 + */ +export type AdditionalOperation = Partial> & { [k: string]: any }; + +export interface AllReservedOperationsInterface { + var: RulesLogic | [RulesLogic] | [RulesLogic, any] | [RulesLogic, any]; + missing: RulesLogic | any[]; + missing_some: [RulesLogic, RulesLogic | any[]]; + if: AnyArrayOfOddLengthMin3; + "==": [any, any]; + "===": [any, any]; + "!=": [any, any]; + "!==": [any, any]; + "!": any; + "!!": any; + or: Array>; + and: Array>; + ">": [RulesLogic, RulesLogic]; + ">=": [RulesLogic, RulesLogic]; + "<": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; + "<=": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; + max: Array>; + min: Array>; + "+": Array> | RulesLogic; + "-": Array> | RulesLogic; + "*": Array> | RulesLogic; + "/": Array> | RulesLogic; + "%": [RulesLogic, RulesLogic]; + map: [RulesLogic, RulesLogic]; + filter: [RulesLogic, RulesLogic]; + reduce: [RulesLogic, RulesLogic, RulesLogic]; + all: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; + none: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; + some: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; + merge: Array> | RulesLogic>; + inArray: [RulesLogic, Array>]; + inString: [RulesLogic, RulesLogic]; + cat: Array>; + substr: [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; + log: RulesLogic; +} + +export type JsonLogicVar = Pick< + AllReservedOperationsInterface, + "var" +>; +export type JsonLogicMissing = Pick< + AllReservedOperationsInterface, + "missing" +>; +export type JsonLogicMissingSome = Pick< + AllReservedOperationsInterface, + "missing_some" +>; +export type JsonLogicIf = Pick; +export type JsonLogicEqual = Pick; +export type JsonLogicStrictEqual = Pick; +export type JsonLogicNotEqual = Pick; +export type JsonLogicNegation = Pick; +export type JsonLogicDoubleNegation = Pick; +export type JsonLogicOr = Pick< + AllReservedOperationsInterface, + "or" +>; +export type JsonLogicAnd = Pick< + AllReservedOperationsInterface, + "and" +>; +export type JsonLogicGreaterThan = Pick< + AllReservedOperationsInterface, + ">" +>; +export type JsonLogicGreaterThanOrEqual = Pick< + AllReservedOperationsInterface, + ">=" +>; +export type JsonLogicLessThan = Pick< + AllReservedOperationsInterface, + "<" +>; +export type JsonLogicLessThanOrEqual = Pick< + AllReservedOperationsInterface, + "<=" +>; +export type JsonLogicMax = Pick< + AllReservedOperationsInterface, + "max" +>; +export type JsonLogicMin = Pick< + AllReservedOperationsInterface, + "min" +>; +export type JsonLogicSum = Pick< + AllReservedOperationsInterface, + "+" +>; +export type JsonLogicDifference = Pick< + AllReservedOperationsInterface, + "-" +>; +export type JsonLogicProduct = Pick< + AllReservedOperationsInterface, + "*" +>; +export type JsonLogicQuotient = Pick< + AllReservedOperationsInterface, + "/" +>; +export type JsonLogicRemainder = Pick< + AllReservedOperationsInterface, + "%" +>; +export type JsonLogicMap = Pick< + AllReservedOperationsInterface, + "map" +>; +export type JsonLogicFilter = Pick< + AllReservedOperationsInterface, + "filter" +>; +export type JsonLogicReduce = Pick< + AllReservedOperationsInterface, + "reduce" +>; +export type JsonLogicAll = Pick< + AllReservedOperationsInterface, + "all" +>; +export type JsonLogicNone = Pick< + AllReservedOperationsInterface, + "none" +>; +export type JsonLogicSome = Pick< + AllReservedOperationsInterface, + "some" +>; +export type JsonLogicMerge = Pick< + AllReservedOperationsInterface, + "merge" +>; +export type JsonLogicInArray = RenameToIn< + Pick, "inArray"> +>; +export type JsonLogicInString = RenameToIn< + Pick, "inString"> +>; +export type JsonLogicCat = Pick< + AllReservedOperationsInterface, + "cat" +>; +export type JsonLogicSubstr = Pick< + AllReservedOperationsInterface, + "substr" +>; +export type JsonLogicLog = Pick< + AllReservedOperationsInterface, + "log" +>; + +export type RulesLogic = + | boolean + | string + | number + | null + // Accessing Data - https://jsonlogic.com/operations.html#accessing-data + | JsonLogicVar + | JsonLogicMissing + | JsonLogicMissingSome + // Logic and Boolean Operations - https://jsonlogic.com/operations.html#logic-and-boolean-operations + | JsonLogicIf + | JsonLogicEqual + | JsonLogicStrictEqual + | JsonLogicNotEqual + | JsonLogicStrictNotEqual + | JsonLogicNegation + | JsonLogicDoubleNegation + | JsonLogicOr + | JsonLogicAnd + // Numeric Operations - https://jsonlogic.com/operations.html#numeric-operations + | JsonLogicGreaterThan + | JsonLogicGreaterThanOrEqual + | JsonLogicLessThan + | JsonLogicLessThanOrEqual + | JsonLogicMax + | JsonLogicMin + | JsonLogicSum + | JsonLogicDifference + | JsonLogicProduct + | JsonLogicQuotient + | JsonLogicRemainder + // Array Operations - https://jsonlogic.com/operations.html#array-operations + | JsonLogicMap + | JsonLogicFilter + | JsonLogicReduce + | JsonLogicAll + | JsonLogicNone + | JsonLogicSome + | JsonLogicMerge + | JsonLogicInArray + // String Operations - https://jsonlogic.com/operations.html#string-operations + | JsonLogicInString + | JsonLogicCat + | JsonLogicSubstr + // Miscellaneous - https://jsonlogic.com/operations.html#miscellaneous + | JsonLogicLog + // Adding Operations (https://jsonlogic.com/add_operation.html) + | AddOps; + +export function add_operation(name: string, code: (...args: any[]) => any): void; +export function apply(logic: RulesLogic, data?: unknown): any; +export function rm_operation(name: string): void; + +// These functions are undocumented, but are exported by the real package +// so they're typed here for completeness. +export function is_logic(logic: any): logic is RulesLogic; +export function truthy(value: any): boolean; +export function get_operator(logic: Record): string; +export function get_values(logic: Record): any; +export function uses_data(logic: Record): any[]; +export function rule_like(rule: any, pattern: any): boolean; + +// @filename: main.ts +import * as jsonLogic from "./json-logic-js"; + +type StartsWithAndEndsWith = + | { startsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] } + | { endsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] }; +type JsonLogicWithAdditionalOperations = jsonLogic.RulesLogic; +const jsonExtendedLogic: JsonLogicWithAdditionalOperations = { + and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }], +}; +jsonLogic.apply(jsonExtendedLogic); diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleStructuralFallback.ts b/tsc/testdata/tests/cases/compiler/varianceCycleStructuralFallback.ts new file mode 100644 index 0000000000000..e3d0f7deff7f5 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleStructuralFallback.ts @@ -0,0 +1,33 @@ +// @strict: true +// @noEmit: true + +// The -? mapped type makes the variance of MA unmeasurable, so comparisons +// of instantiations of MA made while measuring the variances of MA and MB +// fall back to structural comparisons. The variances should not depend on +// which type is measured first. + +// @filename: maFirst.ts +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +type MB = { f: (u: U) => void; a: MA> }; + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +al = as; +as = al; +bl = bs; +bs = bl; + +// @filename: mbFirst.ts +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +type MB = { f: (u: U) => void; a: MA> }; + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +bl = bs; +bs = bl; +al = as; +as = al; diff --git a/tsc/testdata/tests/cases/compiler/varianceDeclarationOrder.ts b/tsc/testdata/tests/cases/compiler/varianceDeclarationOrder.ts new file mode 100644 index 0000000000000..077b736ce3fb4 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceDeclarationOrder.ts @@ -0,0 +1,30 @@ +// @strict: true +// @noEmit: true + +// https://github.com/microsoft/TypeScript/issues/64891 +// The variances of DS must not depend on whether Ref, which mentions DS, +// is declared first. + +// @filename: refFirst.ts +type M = { kind: "m" }; +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +interface Config { measure: keyof T } +interface Ref { dataset: DS, N> } +interface DS { + a(config: Config>): void; + b: Ref; +} +declare const x: DS<{ total: M }, string>; +export const y: DS, string> = x; + +// @filename: dsFirst.ts +type M = { kind: "m" }; +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +interface Config { measure: keyof T } +interface DS { + a(config: Config>): void; + b: Ref; +} +interface Ref { dataset: DS, N> } +declare const x: DS<{ total: M }, string>; +export const y: DS, string> = x; diff --git a/tsc/testdata/tests/cases/compiler/varianceMeasuredWithinCircularity.ts b/tsc/testdata/tests/cases/compiler/varianceMeasuredWithinCircularity.ts new file mode 100644 index 0000000000000..712ee43f4f782 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceMeasuredWithinCircularity.ts @@ -0,0 +1,30 @@ +// @strict: true +// @noEmit: true + +// The variances of Selection and TransitionLike depend on each other. +// The callback of `data` requires Selection to be covariant in P, while +// `join` passes Selection to a callback, which then requires it to +// be contravariant in P, so Selection is invariant in P. TransitionLike +// reaches P of a Selection through `selection().children()`, so it is +// invariant in G. Both must hold whichever variance is measured first. + +export {}; + +interface Base { base: string } +interface Derived extends Base { derived: string } + +interface Selection { + data(key: (parent: P) => string): Selection; + join(enter: string | ((elem: Selection) => Selection | TransitionLike)): Selection; + children(): Selection; +} + +interface TransitionLike { + selection(): Selection; +} + +declare let s1: Selection; +let s2: Selection = s1; + +declare let t1: TransitionLike; +let t2: TransitionLike = t1; diff --git a/tsc/testdata/tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts b/tsc/testdata/tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts new file mode 100644 index 0000000000000..c17ed38541bc4 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts @@ -0,0 +1,21 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +declare let b2: B<"s">; +b1 = b2; + +interface A { m(x: B): Check>; } +interface B { a: A; } +type Check = U extends { a: unknown } ? "yes" : "no"; + +const v: Check> = "yes"; diff --git a/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts b/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts index 45e3ab2f45218..598881ff0189c 100644 --- a/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts +++ b/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @strict: false // @target: es2015 diff --git a/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts b/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts index d72cb1553711e..d3f2b2d3c8455 100644 --- a/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts +++ b/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts @@ -1,6 +1,7 @@ // @strict: true // @target: esnext // @noEmit: true +// @checkOrder: default, typesfirst // https://github.com/microsoft/TypeScript/issues/62993 diff --git a/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts b/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts index 613a3966e161f..ff48d5a86f727 100644 --- a/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts +++ b/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: false // (arg: { x: any, y: any }) => void diff --git a/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts b/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts index 7ad42b8c9fee2..d811998b4c3c5 100644 --- a/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts +++ b/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @checkJs: true // @allowJs: true

+ +interface VisitObj {} +declare class NodePath { +>NodePath : NodePath + + parentPath: NodePath>; +>parentPath : NodePath> + + get: Get; +>get : Get +} +type Get = T extends Array ? Array> : never; +>Get : Get + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).errors.txt b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).errors.txt new file mode 100644 index 0000000000000..a1514a254b857 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).errors.txt @@ -0,0 +1,47 @@ +deleteExpressionMustBeOptional.ts(34,10): error TS2339: Property 'j' does not exist on type 'Foo'. + + +==== deleteExpressionMustBeOptional.ts (1 errors) ==== + interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never + } + + interface AA { + [s: string]: number + } + + type BB = { + [P in keyof any]: number + } + + declare const f: Foo + declare const a: AA + declare const b: BB + + delete f.a + delete f.b + delete f.c + delete f.d + delete f.e + delete f.f + delete f.g + delete f.h + delete f.i + delete f.j + ~ +!!! error TS2339: Property 'j' does not exist on type 'Foo'. + + delete a.a + delete a.b + + delete b.a + delete b.b + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).js b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).js new file mode 100644 index 0000000000000..262eac63738f9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).js @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +//// [deleteExpressionMustBeOptional.ts] +interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never +} + +interface AA { + [s: string]: number +} + +type BB = { + [P in keyof any]: number +} + +declare const f: Foo +declare const a: AA +declare const b: BB + +delete f.a +delete f.b +delete f.c +delete f.d +delete f.e +delete f.f +delete f.g +delete f.h +delete f.i +delete f.j + +delete a.a +delete a.b + +delete b.a +delete b.b + + +//// [deleteExpressionMustBeOptional.js] +"use strict"; +delete f.a; +delete f.b; +delete f.c; +delete f.d; +delete f.e; +delete f.f; +delete f.g; +delete f.h; +delete f.i; +delete f.j; +delete a.a; +delete a.b; +delete b.a; +delete b.b; diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).symbols b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).symbols new file mode 100644 index 0000000000000..9182dec2bc43d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).symbols @@ -0,0 +1,124 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + + a: number +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + + b: number | undefined +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + + c: number | null +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + + d?: number +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + + e: number | undefined | null +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + + f?: number | undefined | null +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + + g: unknown +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + + h: any +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + + i: never +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +} + +interface AA { +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + + [s: string]: number +>s : Symbol(s, Decl(deleteExpressionMustBeOptional.ts, 13, 5)) +} + +type BB = { +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + + [P in keyof any]: number +>P : Symbol(P, Decl(deleteExpressionMustBeOptional.ts, 17, 5)) +} + +declare const f: Foo +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + +declare const a: AA +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + +declare const b: BB +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + +delete f.a +>f.a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + +delete f.b +>f.b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + +delete f.c +>f.c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + +delete f.d +>f.d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + +delete f.e +>f.e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + +delete f.f +>f.f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + +delete f.g +>f.g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + +delete f.h +>f.h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + +delete f.i +>f.i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) + +delete f.j +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) + +delete a.a +>a.a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete a.b +>a.b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete b.a +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + +delete b.b +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).types b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).types new file mode 100644 index 0000000000000..3c0777475c7fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).types @@ -0,0 +1,136 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { + a: number +>a : number + + b: number | undefined +>b : number + + c: number | null +>c : number + + d?: number +>d : number + + e: number | undefined | null +>e : number + + f?: number | undefined | null +>f : number + + g: unknown +>g : unknown + + h: any +>h : any + + i: never +>i : never +} + +interface AA { + [s: string]: number +>s : string +} + +type BB = { +>BB : BB + + [P in keyof any]: number +} + +declare const f: Foo +>f : Foo + +declare const a: AA +>a : AA + +declare const b: BB +>b : BB + +delete f.a +>delete f.a : boolean +>f.a : number +>f : Foo +>a : number + +delete f.b +>delete f.b : boolean +>f.b : number +>f : Foo +>b : number + +delete f.c +>delete f.c : boolean +>f.c : number +>f : Foo +>c : number + +delete f.d +>delete f.d : boolean +>f.d : number +>f : Foo +>d : number + +delete f.e +>delete f.e : boolean +>f.e : number +>f : Foo +>e : number + +delete f.f +>delete f.f : boolean +>f.f : number +>f : Foo +>f : number + +delete f.g +>delete f.g : boolean +>f.g : unknown +>f : Foo +>g : unknown + +delete f.h +>delete f.h : boolean +>f.h : any +>f : Foo +>h : any + +delete f.i +>delete f.i : boolean +>f.i : never +>f : Foo +>i : never + +delete f.j +>delete f.j : boolean +>f.j : any +>f : Foo +>j : any + +delete a.a +>delete a.a : boolean +>a.a : number +>a : AA +>a : number + +delete a.b +>delete a.b : boolean +>a.b : number +>a : AA +>b : number + +delete b.a +>delete b.a : boolean +>b.a : number +>b : BB +>a : number + +delete b.b +>delete b.b : boolean +>b.b : number +>b : BB +>b : number + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).errors.txt b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).errors.txt new file mode 100644 index 0000000000000..f3abcf0386f5b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).errors.txt @@ -0,0 +1,53 @@ +deleteExpressionMustBeOptional.ts(25,8): error TS2790: The operand of a 'delete' operator must be optional. +deleteExpressionMustBeOptional.ts(27,8): error TS2790: The operand of a 'delete' operator must be optional. +deleteExpressionMustBeOptional.ts(34,10): error TS2339: Property 'j' does not exist on type 'Foo'. + + +==== deleteExpressionMustBeOptional.ts (3 errors) ==== + interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never + } + + interface AA { + [s: string]: number + } + + type BB = { + [P in keyof any]: number + } + + declare const f: Foo + declare const a: AA + declare const b: BB + + delete f.a + ~~~ +!!! error TS2790: The operand of a 'delete' operator must be optional. + delete f.b + delete f.c + ~~~ +!!! error TS2790: The operand of a 'delete' operator must be optional. + delete f.d + delete f.e + delete f.f + delete f.g + delete f.h + delete f.i + delete f.j + ~ +!!! error TS2339: Property 'j' does not exist on type 'Foo'. + + delete a.a + delete a.b + + delete b.a + delete b.b + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).js b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).js new file mode 100644 index 0000000000000..262eac63738f9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).js @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +//// [deleteExpressionMustBeOptional.ts] +interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never +} + +interface AA { + [s: string]: number +} + +type BB = { + [P in keyof any]: number +} + +declare const f: Foo +declare const a: AA +declare const b: BB + +delete f.a +delete f.b +delete f.c +delete f.d +delete f.e +delete f.f +delete f.g +delete f.h +delete f.i +delete f.j + +delete a.a +delete a.b + +delete b.a +delete b.b + + +//// [deleteExpressionMustBeOptional.js] +"use strict"; +delete f.a; +delete f.b; +delete f.c; +delete f.d; +delete f.e; +delete f.f; +delete f.g; +delete f.h; +delete f.i; +delete f.j; +delete a.a; +delete a.b; +delete b.a; +delete b.b; diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).symbols b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).symbols new file mode 100644 index 0000000000000..9182dec2bc43d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).symbols @@ -0,0 +1,124 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + + a: number +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + + b: number | undefined +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + + c: number | null +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + + d?: number +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + + e: number | undefined | null +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + + f?: number | undefined | null +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + + g: unknown +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + + h: any +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + + i: never +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +} + +interface AA { +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + + [s: string]: number +>s : Symbol(s, Decl(deleteExpressionMustBeOptional.ts, 13, 5)) +} + +type BB = { +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + + [P in keyof any]: number +>P : Symbol(P, Decl(deleteExpressionMustBeOptional.ts, 17, 5)) +} + +declare const f: Foo +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + +declare const a: AA +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + +declare const b: BB +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + +delete f.a +>f.a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + +delete f.b +>f.b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + +delete f.c +>f.c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + +delete f.d +>f.d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + +delete f.e +>f.e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + +delete f.f +>f.f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + +delete f.g +>f.g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + +delete f.h +>f.h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + +delete f.i +>f.i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) + +delete f.j +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) + +delete a.a +>a.a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete a.b +>a.b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete b.a +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + +delete b.b +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).types b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).types new file mode 100644 index 0000000000000..9a17de9e03b2e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).types @@ -0,0 +1,136 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { + a: number +>a : number + + b: number | undefined +>b : number | undefined + + c: number | null +>c : number | null + + d?: number +>d : number | undefined + + e: number | undefined | null +>e : number | null | undefined + + f?: number | undefined | null +>f : number | null | undefined + + g: unknown +>g : unknown + + h: any +>h : any + + i: never +>i : never +} + +interface AA { + [s: string]: number +>s : string +} + +type BB = { +>BB : BB + + [P in keyof any]: number +} + +declare const f: Foo +>f : Foo + +declare const a: AA +>a : AA + +declare const b: BB +>b : BB + +delete f.a +>delete f.a : boolean +>f.a : number +>f : Foo +>a : number + +delete f.b +>delete f.b : boolean +>f.b : number | undefined +>f : Foo +>b : number | undefined + +delete f.c +>delete f.c : boolean +>f.c : number | null +>f : Foo +>c : number | null + +delete f.d +>delete f.d : boolean +>f.d : number | undefined +>f : Foo +>d : number | undefined + +delete f.e +>delete f.e : boolean +>f.e : number | null | undefined +>f : Foo +>e : number | null | undefined + +delete f.f +>delete f.f : boolean +>f.f : number | null | undefined +>f : Foo +>f : number | null | undefined + +delete f.g +>delete f.g : boolean +>f.g : unknown +>f : Foo +>g : unknown + +delete f.h +>delete f.h : boolean +>f.h : any +>f : Foo +>h : any + +delete f.i +>delete f.i : boolean +>f.i : never +>f : Foo +>i : never + +delete f.j +>delete f.j : boolean +>f.j : any +>f : Foo +>j : any + +delete a.a +>delete a.a : boolean +>a.a : number +>a : AA +>a : number + +delete a.b +>delete a.b : boolean +>a.b : number +>a : AA +>b : number + +delete b.a +>delete b.a : boolean +>b.a : number +>b : BB +>a : number + +delete b.b +>delete b.b : boolean +>b.b : number +>b : BB +>b : number + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).errors.txt b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).errors.txt new file mode 100644 index 0000000000000..a1514a254b857 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).errors.txt @@ -0,0 +1,47 @@ +deleteExpressionMustBeOptional.ts(34,10): error TS2339: Property 'j' does not exist on type 'Foo'. + + +==== deleteExpressionMustBeOptional.ts (1 errors) ==== + interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never + } + + interface AA { + [s: string]: number + } + + type BB = { + [P in keyof any]: number + } + + declare const f: Foo + declare const a: AA + declare const b: BB + + delete f.a + delete f.b + delete f.c + delete f.d + delete f.e + delete f.f + delete f.g + delete f.h + delete f.i + delete f.j + ~ +!!! error TS2339: Property 'j' does not exist on type 'Foo'. + + delete a.a + delete a.b + + delete b.a + delete b.b + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).js b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).js new file mode 100644 index 0000000000000..262eac63738f9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).js @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +//// [deleteExpressionMustBeOptional.ts] +interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never +} + +interface AA { + [s: string]: number +} + +type BB = { + [P in keyof any]: number +} + +declare const f: Foo +declare const a: AA +declare const b: BB + +delete f.a +delete f.b +delete f.c +delete f.d +delete f.e +delete f.f +delete f.g +delete f.h +delete f.i +delete f.j + +delete a.a +delete a.b + +delete b.a +delete b.b + + +//// [deleteExpressionMustBeOptional.js] +"use strict"; +delete f.a; +delete f.b; +delete f.c; +delete f.d; +delete f.e; +delete f.f; +delete f.g; +delete f.h; +delete f.i; +delete f.j; +delete a.a; +delete a.b; +delete b.a; +delete b.b; diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).symbols b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).symbols new file mode 100644 index 0000000000000..9182dec2bc43d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).symbols @@ -0,0 +1,124 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + + a: number +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + + b: number | undefined +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + + c: number | null +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + + d?: number +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + + e: number | undefined | null +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + + f?: number | undefined | null +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + + g: unknown +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + + h: any +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + + i: never +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +} + +interface AA { +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + + [s: string]: number +>s : Symbol(s, Decl(deleteExpressionMustBeOptional.ts, 13, 5)) +} + +type BB = { +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + + [P in keyof any]: number +>P : Symbol(P, Decl(deleteExpressionMustBeOptional.ts, 17, 5)) +} + +declare const f: Foo +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + +declare const a: AA +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + +declare const b: BB +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + +delete f.a +>f.a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + +delete f.b +>f.b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + +delete f.c +>f.c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + +delete f.d +>f.d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + +delete f.e +>f.e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + +delete f.f +>f.f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + +delete f.g +>f.g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + +delete f.h +>f.h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + +delete f.i +>f.i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) + +delete f.j +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) + +delete a.a +>a.a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete a.b +>a.b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete b.a +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + +delete b.b +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).types b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).types new file mode 100644 index 0000000000000..3c0777475c7fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).types @@ -0,0 +1,136 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { + a: number +>a : number + + b: number | undefined +>b : number + + c: number | null +>c : number + + d?: number +>d : number + + e: number | undefined | null +>e : number + + f?: number | undefined | null +>f : number + + g: unknown +>g : unknown + + h: any +>h : any + + i: never +>i : never +} + +interface AA { + [s: string]: number +>s : string +} + +type BB = { +>BB : BB + + [P in keyof any]: number +} + +declare const f: Foo +>f : Foo + +declare const a: AA +>a : AA + +declare const b: BB +>b : BB + +delete f.a +>delete f.a : boolean +>f.a : number +>f : Foo +>a : number + +delete f.b +>delete f.b : boolean +>f.b : number +>f : Foo +>b : number + +delete f.c +>delete f.c : boolean +>f.c : number +>f : Foo +>c : number + +delete f.d +>delete f.d : boolean +>f.d : number +>f : Foo +>d : number + +delete f.e +>delete f.e : boolean +>f.e : number +>f : Foo +>e : number + +delete f.f +>delete f.f : boolean +>f.f : number +>f : Foo +>f : number + +delete f.g +>delete f.g : boolean +>f.g : unknown +>f : Foo +>g : unknown + +delete f.h +>delete f.h : boolean +>f.h : any +>f : Foo +>h : any + +delete f.i +>delete f.i : boolean +>f.i : never +>f : Foo +>i : never + +delete f.j +>delete f.j : boolean +>f.j : any +>f : Foo +>j : any + +delete a.a +>delete a.a : boolean +>a.a : number +>a : AA +>a : number + +delete a.b +>delete a.b : boolean +>a.b : number +>a : AA +>b : number + +delete b.a +>delete b.a : boolean +>b.a : number +>b : BB +>a : number + +delete b.b +>delete b.b : boolean +>b.b : number +>b : BB +>b : number + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).errors.txt b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).errors.txt new file mode 100644 index 0000000000000..f3abcf0386f5b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).errors.txt @@ -0,0 +1,53 @@ +deleteExpressionMustBeOptional.ts(25,8): error TS2790: The operand of a 'delete' operator must be optional. +deleteExpressionMustBeOptional.ts(27,8): error TS2790: The operand of a 'delete' operator must be optional. +deleteExpressionMustBeOptional.ts(34,10): error TS2339: Property 'j' does not exist on type 'Foo'. + + +==== deleteExpressionMustBeOptional.ts (3 errors) ==== + interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never + } + + interface AA { + [s: string]: number + } + + type BB = { + [P in keyof any]: number + } + + declare const f: Foo + declare const a: AA + declare const b: BB + + delete f.a + ~~~ +!!! error TS2790: The operand of a 'delete' operator must be optional. + delete f.b + delete f.c + ~~~ +!!! error TS2790: The operand of a 'delete' operator must be optional. + delete f.d + delete f.e + delete f.f + delete f.g + delete f.h + delete f.i + delete f.j + ~ +!!! error TS2339: Property 'j' does not exist on type 'Foo'. + + delete a.a + delete a.b + + delete b.a + delete b.b + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).js b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).js new file mode 100644 index 0000000000000..262eac63738f9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).js @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +//// [deleteExpressionMustBeOptional.ts] +interface Foo { + a: number + b: number | undefined + c: number | null + d?: number + e: number | undefined | null + f?: number | undefined | null + g: unknown + h: any + i: never +} + +interface AA { + [s: string]: number +} + +type BB = { + [P in keyof any]: number +} + +declare const f: Foo +declare const a: AA +declare const b: BB + +delete f.a +delete f.b +delete f.c +delete f.d +delete f.e +delete f.f +delete f.g +delete f.h +delete f.i +delete f.j + +delete a.a +delete a.b + +delete b.a +delete b.b + + +//// [deleteExpressionMustBeOptional.js] +"use strict"; +delete f.a; +delete f.b; +delete f.c; +delete f.d; +delete f.e; +delete f.f; +delete f.g; +delete f.h; +delete f.i; +delete f.j; +delete a.a; +delete a.b; +delete b.a; +delete b.b; diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).symbols b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).symbols new file mode 100644 index 0000000000000..9182dec2bc43d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).symbols @@ -0,0 +1,124 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + + a: number +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + + b: number | undefined +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + + c: number | null +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + + d?: number +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + + e: number | undefined | null +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + + f?: number | undefined | null +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + + g: unknown +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + + h: any +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + + i: never +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +} + +interface AA { +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + + [s: string]: number +>s : Symbol(s, Decl(deleteExpressionMustBeOptional.ts, 13, 5)) +} + +type BB = { +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + + [P in keyof any]: number +>P : Symbol(P, Decl(deleteExpressionMustBeOptional.ts, 17, 5)) +} + +declare const f: Foo +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional.ts, 0, 0)) + +declare const a: AA +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional.ts, 10, 1)) + +declare const b: BB +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) +>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional.ts, 14, 1)) + +delete f.a +>f.a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional.ts, 0, 15)) + +delete f.b +>f.b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional.ts, 1, 13)) + +delete f.c +>f.c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional.ts, 2, 25)) + +delete f.d +>f.d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional.ts, 3, 20)) + +delete f.e +>f.e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional.ts, 4, 14)) + +delete f.f +>f.f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional.ts, 5, 32)) + +delete f.g +>f.g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional.ts, 6, 33)) + +delete f.h +>f.h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional.ts, 7, 14)) + +delete f.i +>f.i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) +>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional.ts, 8, 10)) + +delete f.j +>f : Symbol(f, Decl(deleteExpressionMustBeOptional.ts, 20, 13)) + +delete a.a +>a.a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>a : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete a.b +>a.b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) +>a : Symbol(a, Decl(deleteExpressionMustBeOptional.ts, 21, 13)) +>b : Symbol(AA.__index, Decl(deleteExpressionMustBeOptional.ts, 12, 14)) + +delete b.a +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + +delete b.b +>b : Symbol(b, Decl(deleteExpressionMustBeOptional.ts, 22, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).types b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).types new file mode 100644 index 0000000000000..9a17de9e03b2e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).types @@ -0,0 +1,136 @@ +//// [tests/cases/compiler/deleteExpressionMustBeOptional.ts] //// + +=== deleteExpressionMustBeOptional.ts === +interface Foo { + a: number +>a : number + + b: number | undefined +>b : number | undefined + + c: number | null +>c : number | null + + d?: number +>d : number | undefined + + e: number | undefined | null +>e : number | null | undefined + + f?: number | undefined | null +>f : number | null | undefined + + g: unknown +>g : unknown + + h: any +>h : any + + i: never +>i : never +} + +interface AA { + [s: string]: number +>s : string +} + +type BB = { +>BB : BB + + [P in keyof any]: number +} + +declare const f: Foo +>f : Foo + +declare const a: AA +>a : AA + +declare const b: BB +>b : BB + +delete f.a +>delete f.a : boolean +>f.a : number +>f : Foo +>a : number + +delete f.b +>delete f.b : boolean +>f.b : number | undefined +>f : Foo +>b : number | undefined + +delete f.c +>delete f.c : boolean +>f.c : number | null +>f : Foo +>c : number | null + +delete f.d +>delete f.d : boolean +>f.d : number | undefined +>f : Foo +>d : number | undefined + +delete f.e +>delete f.e : boolean +>f.e : number | null | undefined +>f : Foo +>e : number | null | undefined + +delete f.f +>delete f.f : boolean +>f.f : number | null | undefined +>f : Foo +>f : number | null | undefined + +delete f.g +>delete f.g : boolean +>f.g : unknown +>f : Foo +>g : unknown + +delete f.h +>delete f.h : boolean +>f.h : any +>f : Foo +>h : any + +delete f.i +>delete f.i : boolean +>f.i : never +>f : Foo +>i : never + +delete f.j +>delete f.j : boolean +>f.j : any +>f : Foo +>j : any + +delete a.a +>delete a.a : boolean +>a.a : number +>a : AA +>a : number + +delete a.b +>delete a.b : boolean +>a.b : number +>a : AA +>b : number + +delete b.a +>delete b.a : boolean +>b.a : number +>b : BB +>a : number + +delete b.b +>delete b.b : boolean +>b.b : number +>b : BB +>b : number + diff --git a/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).symbols new file mode 100644 index 0000000000000..0aaf38011344f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).symbols @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts] //// + +=== dependentDestructuringBindingElementInitializer.ts === +type U = +>U : Symbol(U, Decl(dependentDestructuringBindingElementInitializer.ts, 0, 0)) + + | { kind: "a"; payload: number; extra?: unknown } +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 1, 7)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 1, 18)) +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 1, 35)) + + | { kind: "b"; payload: string; extra?: unknown }; +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 2, 7)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 2, 18)) +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 2, 35)) + +declare const u: U; +>u : Symbol(u, Decl(dependentDestructuringBindingElementInitializer.ts, 4, 13)) +>U : Symbol(U, Decl(dependentDestructuringBindingElementInitializer.ts, 0, 0)) + +const { + kind, +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 6, 7)) + + payload, +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 7, 9)) + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 8, 12)) +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 6, 7)) +>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 7, 9)) +>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 7, 9)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + +} = u; +>u : Symbol(u, Decl(dependentDestructuringBindingElementInitializer.ts, 4, 13)) + +function f({ +>f : Symbol(f, Decl(dependentDestructuringBindingElementInitializer.ts, 10, 6)) + + kind, +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 12, 12)) + + payload, +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 13, 9)) + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 14, 12)) +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 12, 12)) +>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 13, 9)) +>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 13, 9)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + +}: U) {} +>U : Symbol(U, Decl(dependentDestructuringBindingElementInitializer.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).types new file mode 100644 index 0000000000000..0dcd3d8a64cef --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).types @@ -0,0 +1,70 @@ +//// [tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts] //// + +=== dependentDestructuringBindingElementInitializer.ts === +type U = +>U : U + + | { kind: "a"; payload: number; extra?: unknown } +>kind : "a" +>payload : number +>extra : unknown + + | { kind: "b"; payload: string; extra?: unknown }; +>kind : "b" +>payload : string +>extra : unknown + +declare const u: U; +>u : U + +const { + kind, +>kind : "a" | "b" + + payload, +>payload : string | number + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : unknown +>kind === "a" ? payload.toFixed() : payload.toUpperCase() : string +>kind === "a" : boolean +>kind : "a" | "b" +>"a" : "a" +>payload.toFixed() : string +>payload.toFixed : (fractionDigits?: number) => string +>payload : number +>toFixed : (fractionDigits?: number) => string +>payload.toUpperCase() : string +>payload.toUpperCase : () => string +>payload : string +>toUpperCase : () => string + +} = u; +>u : U + +function f({ +>f : ({ kind, payload, extra, }: U) => void + + kind, +>kind : "a" | "b" + + payload, +>payload : string | number + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : unknown +>kind === "a" ? payload.toFixed() : payload.toUpperCase() : string +>kind === "a" : boolean +>kind : "a" | "b" +>"a" : "a" +>payload.toFixed() : string +>payload.toFixed : (fractionDigits?: number) => string +>payload : number +>toFixed : (fractionDigits?: number) => string +>payload.toUpperCase() : string +>payload.toUpperCase : () => string +>payload : string +>toUpperCase : () => string + +}: U) {} + diff --git a/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..0aaf38011344f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).symbols @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts] //// + +=== dependentDestructuringBindingElementInitializer.ts === +type U = +>U : Symbol(U, Decl(dependentDestructuringBindingElementInitializer.ts, 0, 0)) + + | { kind: "a"; payload: number; extra?: unknown } +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 1, 7)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 1, 18)) +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 1, 35)) + + | { kind: "b"; payload: string; extra?: unknown }; +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 2, 7)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 2, 18)) +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 2, 35)) + +declare const u: U; +>u : Symbol(u, Decl(dependentDestructuringBindingElementInitializer.ts, 4, 13)) +>U : Symbol(U, Decl(dependentDestructuringBindingElementInitializer.ts, 0, 0)) + +const { + kind, +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 6, 7)) + + payload, +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 7, 9)) + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 8, 12)) +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 6, 7)) +>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 7, 9)) +>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 7, 9)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + +} = u; +>u : Symbol(u, Decl(dependentDestructuringBindingElementInitializer.ts, 4, 13)) + +function f({ +>f : Symbol(f, Decl(dependentDestructuringBindingElementInitializer.ts, 10, 6)) + + kind, +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 12, 12)) + + payload, +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 13, 9)) + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : Symbol(extra, Decl(dependentDestructuringBindingElementInitializer.ts, 14, 12)) +>kind : Symbol(kind, Decl(dependentDestructuringBindingElementInitializer.ts, 12, 12)) +>payload.toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 13, 9)) +>toFixed : Symbol(Number.toFixed, Decl(lib.es5.d.ts, --, --)) +>payload.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>payload : Symbol(payload, Decl(dependentDestructuringBindingElementInitializer.ts, 13, 9)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + +}: U) {} +>U : Symbol(U, Decl(dependentDestructuringBindingElementInitializer.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types new file mode 100644 index 0000000000000..0dcd3d8a64cef --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types @@ -0,0 +1,70 @@ +//// [tests/cases/compiler/dependentDestructuringBindingElementInitializer.ts] //// + +=== dependentDestructuringBindingElementInitializer.ts === +type U = +>U : U + + | { kind: "a"; payload: number; extra?: unknown } +>kind : "a" +>payload : number +>extra : unknown + + | { kind: "b"; payload: string; extra?: unknown }; +>kind : "b" +>payload : string +>extra : unknown + +declare const u: U; +>u : U + +const { + kind, +>kind : "a" | "b" + + payload, +>payload : string | number + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : unknown +>kind === "a" ? payload.toFixed() : payload.toUpperCase() : string +>kind === "a" : boolean +>kind : "a" | "b" +>"a" : "a" +>payload.toFixed() : string +>payload.toFixed : (fractionDigits?: number) => string +>payload : number +>toFixed : (fractionDigits?: number) => string +>payload.toUpperCase() : string +>payload.toUpperCase : () => string +>payload : string +>toUpperCase : () => string + +} = u; +>u : U + +function f({ +>f : ({ kind, payload, extra, }: U) => void + + kind, +>kind : "a" | "b" + + payload, +>payload : string | number + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : unknown +>kind === "a" ? payload.toFixed() : payload.toUpperCase() : string +>kind === "a" : boolean +>kind : "a" | "b" +>"a" : "a" +>payload.toFixed() : string +>payload.toFixed : (fractionDigits?: number) => string +>payload : number +>toFixed : (fractionDigits?: number) => string +>payload.toUpperCase() : string +>payload.toUpperCase : () => string +>payload : string +>toUpperCase : () => string + +}: U) {} + diff --git a/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.symbols b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.symbols new file mode 100644 index 0000000000000..06df0f2a50571 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts] //// + +=== distributiveConstraintOfCircularCheckType.ts === +// The base constraint of Collect is circular, since its +// constraint includes Collect, whose constraint includes itself. +// Distributing Parameters over that constraint leads back into the +// circularity, so Parameters> must instead have the +// constraint of its branches, unknown[], and be spreadable. + +type Collect = +>Collect : Symbol(Collect, Decl(distributiveConstraintOfCircularCheckType.ts, 0, 0)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>Result : Symbol(Result, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 15)) + + Result & F extends (arg: infer A) => infer R +>Result : Symbol(Result, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 15)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>arg : Symbol(arg, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 24)) +>A : Symbol(A, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 34)) +>R : Symbol(R, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 46)) + + ? Collect | (() => R) +>Collect : Symbol(Collect, Decl(distributiveConstraintOfCircularCheckType.ts, 0, 0)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>R : Symbol(R, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 46)) + + : never; + +function pipe unknown>(args: Parameters>, f: F) { +>pipe : Symbol(pipe, Decl(distributiveConstraintOfCircularCheckType.ts, 9, 16)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 14)) +>args : Symbol(args, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 25)) +>args : Symbol(args, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 51)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>Collect : Symbol(Collect, Decl(distributiveConstraintOfCircularCheckType.ts, 0, 0)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 14)) +>f : Symbol(f, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 89)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 14)) + + f(...args); +>f : Symbol(f, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 89)) +>args : Symbol(args, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 51)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.types b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.types new file mode 100644 index 0000000000000..5a0f4a282fbac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts] //// + +=== distributiveConstraintOfCircularCheckType.ts === +// The base constraint of Collect is circular, since its +// constraint includes Collect, whose constraint includes itself. +// Distributing Parameters over that constraint leads back into the +// circularity, so Parameters> must instead have the +// constraint of its branches, unknown[], and be spreadable. + +type Collect = +>Collect : Collect + + Result & F extends (arg: infer A) => infer R +>arg : A + + ? Collect | (() => R) + : never; + +function pipe unknown>(args: Parameters>, f: F) { +>pipe : unknown>(args: Parameters>, f: F) => void +>args : any +>args : Parameters> +>f : F + + f(...args); +>f(...args) : unknown +>f : F +>...args : unknown +>args : Parameters> +} + diff --git a/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.js b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.js new file mode 100644 index 0000000000000..774af8292c6a9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/enumMemberTypeCacheConsistency.ts] //// + +//// [enumMemberTypeCacheConsistency.ts] +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; + +//// [enumMemberTypeCacheConsistency.js] +"use strict"; +var E; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = E.A.valueOf()] = "B"; + E[E["C"] = 1] = "C"; +})(E || (E = {})); +const member = E.C; + + +//// [enumMemberTypeCacheConsistency.d.ts] +declare enum E { + A = 0, + B, + C = 1 +} +declare const member: Extract; diff --git a/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.symbols b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.symbols new file mode 100644 index 0000000000000..d527b2792f38e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/enumMemberTypeCacheConsistency.ts] //// + +=== enumMemberTypeCacheConsistency.ts === +enum E { +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) + + A = 0, +>A : Symbol(E.A, Decl(enumMemberTypeCacheConsistency.ts, 0, 8)) + + B = E.A.valueOf(), +>B : Symbol(E.B, Decl(enumMemberTypeCacheConsistency.ts, 1, 10)) +>E.A.valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) +>E.A : Symbol(E.A, Decl(enumMemberTypeCacheConsistency.ts, 0, 8)) +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) +>A : Symbol(E.A, Decl(enumMemberTypeCacheConsistency.ts, 0, 8)) +>valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) + + C = 1, +>C : Symbol(E.C, Decl(enumMemberTypeCacheConsistency.ts, 2, 22)) +} + +const member: Extract = E.C; +>member : Symbol(member, Decl(enumMemberTypeCacheConsistency.ts, 6, 5)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) +>E.C : Symbol(E.C, Decl(enumMemberTypeCacheConsistency.ts, 2, 22)) +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) +>C : Symbol(E.C, Decl(enumMemberTypeCacheConsistency.ts, 2, 22)) + diff --git a/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.types b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.types new file mode 100644 index 0000000000000..118dbac02ec0b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/enumMemberTypeCacheConsistency.ts] //// + +=== enumMemberTypeCacheConsistency.ts === +enum E { +>E : E + + A = 0, +>A : E.A +>0 : 0 + + B = E.A.valueOf(), +>B : E.B +>E.A.valueOf() : number +>E.A.valueOf : () => number +>E.A : E.A +>E : typeof E +>A : E.A +>valueOf : () => number + + C = 1, +>C : E.C +>1 : 1 +} + +const member: Extract = E.C; +>member : E.C +>E.C : E.C +>E : typeof E +>C : E.C + diff --git a/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.symbols b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.symbols new file mode 100644 index 0000000000000..f78b71ec020dd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/evolvingArrayReadInLoopCondition.ts] //// + +=== evolvingArrayReadInLoopCondition.ts === +// Narrowing by the condition needs the type of `seen` at the call, which +// depends on the analysis of the loop in progress for that same read. Once +// the loop is analyzed, `seen` is number[] there, so no error should say that +// its type cannot be determined. + +declare const x: number; +>x : Symbol(x, Decl(evolvingArrayReadInLoopCondition.ts, 5, 13)) + +const seen = []; +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) + +for (let i = 0; i < 3; i++) { +>i : Symbol(i, Decl(evolvingArrayReadInLoopCondition.ts, 7, 8)) +>i : Symbol(i, Decl(evolvingArrayReadInLoopCondition.ts, 7, 8)) +>i : Symbol(i, Decl(evolvingArrayReadInLoopCondition.ts, 7, 8)) + + if (!seen.some(s => true)) { +>seen.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --)) +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(evolvingArrayReadInLoopCondition.ts, 8, 19)) + + seen.push(x); +>seen.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>x : Symbol(x, Decl(evolvingArrayReadInLoopCondition.ts, 5, 13)) + } +} +const result = seen; +>result : Symbol(result, Decl(evolvingArrayReadInLoopCondition.ts, 12, 5)) +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.types b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.types new file mode 100644 index 0000000000000..6b413578e01e5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.types @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/evolvingArrayReadInLoopCondition.ts] //// + +=== evolvingArrayReadInLoopCondition.ts === +// Narrowing by the condition needs the type of `seen` at the call, which +// depends on the analysis of the loop in progress for that same read. Once +// the loop is analyzed, `seen` is number[] there, so no error should say that +// its type cannot be determined. + +declare const x: number; +>x : number + +const seen = []; +>seen : any[] +>[] : never[] + +for (let i = 0; i < 3; i++) { +>i : number +>0 : 0 +>i < 3 : boolean +>i : number +>3 : 3 +>i++ : number +>i : number + + if (!seen.some(s => true)) { +>!seen.some(s => true) : boolean +>seen.some(s => true) : boolean +>seen.some : (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean +>seen : number[] +>some : (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean +>s => true : (s: number) => boolean +>s : number +>true : true + + seen.push(x); +>seen.push(x) : number +>seen.push : (...items: any[]) => number +>seen : any[] +>push : (...items: any[]) => number +>x : number + } +} +const result = seen; +>result : number[] +>seen : number[] + diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).errors.txt new file mode 100644 index 0000000000000..6ec6fc6629d8a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).errors.txt @@ -0,0 +1,51 @@ +excessivelyLargeTupleSpread.ts(6,10): error TS2799: Type produces a tuple type that is too large to represent. +excessivelyLargeTupleSpread.ts(22,12): error TS2799: Type produces a tuple type that is too large to represent. +excessivelyLargeTupleSpread.ts(38,13): error TS2800: Expression produces a tuple type that is too large to represent. + + +==== excessivelyLargeTupleSpread.ts (3 errors) ==== + // #41771 + + type BuildTuple = + T['length'] extends L ? T : BuildTuple; + + type A = BuildTuple<3> + ~~~~~~~~~~~~~ +!!! error TS2799: Type produces a tuple type that is too large to represent. + + type T0 = [any]; + type T1 = [...T0, ...T0]; + type T2 = [...T1, ...T1]; + type T3 = [...T2, ...T2]; + type T4 = [...T3, ...T3]; + type T5 = [...T4, ...T4]; + type T6 = [...T5, ...T5]; + type T7 = [...T6, ...T6]; + type T8 = [...T7, ...T7]; + type T9 = [...T8, ...T8]; + type T10 = [...T9, ...T9]; + type T11 = [...T10, ...T10]; + type T12 = [...T11, ...T11]; + type T13 = [...T12, ...T12]; + type T14 = [...T13, ...T13]; // 2^14 > 10,000 + ~~~~~~~~~~~~~~~~ +!!! error TS2799: Type produces a tuple type that is too large to represent. + + const a0 = [0] as const; + const a1 = [...a0, ...a0] as const; + const a2 = [...a1, ...a1] as const; + const a3 = [...a2, ...a2] as const; + const a4 = [...a3, ...a3] as const; + const a5 = [...a4, ...a4] as const; + const a6 = [...a5, ...a5] as const; + const a7 = [...a6, ...a6] as const; + const a8 = [...a7, ...a7] as const; + const a9 = [...a8, ...a8] as const; + const a10 = [...a9, ...a9] as const; + const a11 = [...a10, ...a10] as const; + const a12 = [...a11, ...a11] as const; + const a13 = [...a12, ...a12] as const; + const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 + ~~~~~~~~~~~~~~~~ +!!! error TS2800: Expression produces a tuple type that is too large to represent. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).js new file mode 100644 index 0000000000000..bbb96dcc93129 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).js @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/excessivelyLargeTupleSpread.ts] //// + +//// [excessivelyLargeTupleSpread.ts] +// #41771 + +type BuildTuple = + T['length'] extends L ? T : BuildTuple; + +type A = BuildTuple<3> + +type T0 = [any]; +type T1 = [...T0, ...T0]; +type T2 = [...T1, ...T1]; +type T3 = [...T2, ...T2]; +type T4 = [...T3, ...T3]; +type T5 = [...T4, ...T4]; +type T6 = [...T5, ...T5]; +type T7 = [...T6, ...T6]; +type T8 = [...T7, ...T7]; +type T9 = [...T8, ...T8]; +type T10 = [...T9, ...T9]; +type T11 = [...T10, ...T10]; +type T12 = [...T11, ...T11]; +type T13 = [...T12, ...T12]; +type T14 = [...T13, ...T13]; // 2^14 > 10,000 + +const a0 = [0] as const; +const a1 = [...a0, ...a0] as const; +const a2 = [...a1, ...a1] as const; +const a3 = [...a2, ...a2] as const; +const a4 = [...a3, ...a3] as const; +const a5 = [...a4, ...a4] as const; +const a6 = [...a5, ...a5] as const; +const a7 = [...a6, ...a6] as const; +const a8 = [...a7, ...a7] as const; +const a9 = [...a8, ...a8] as const; +const a10 = [...a9, ...a9] as const; +const a11 = [...a10, ...a10] as const; +const a12 = [...a11, ...a11] as const; +const a13 = [...a12, ...a12] as const; +const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 + + +//// [excessivelyLargeTupleSpread.js] +"use strict"; +// #41771 +const a0 = [0]; +const a1 = [...a0, ...a0]; +const a2 = [...a1, ...a1]; +const a3 = [...a2, ...a2]; +const a4 = [...a3, ...a3]; +const a5 = [...a4, ...a4]; +const a6 = [...a5, ...a5]; +const a7 = [...a6, ...a6]; +const a8 = [...a7, ...a7]; +const a9 = [...a8, ...a8]; +const a10 = [...a9, ...a9]; +const a11 = [...a10, ...a10]; +const a12 = [...a11, ...a11]; +const a13 = [...a12, ...a12]; +const a14 = [...a13, ...a13]; // 2^14 > 10,000 diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).symbols new file mode 100644 index 0000000000000..629d43f9085cf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).symbols @@ -0,0 +1,184 @@ +//// [tests/cases/compiler/excessivelyLargeTupleSpread.ts] //// + +=== excessivelyLargeTupleSpread.ts === +// #41771 + +type BuildTuple = +>BuildTuple : Symbol(BuildTuple, Decl(excessivelyLargeTupleSpread.ts, 0, 0)) +>L : Symbol(L, Decl(excessivelyLargeTupleSpread.ts, 2, 16)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) + + T['length'] extends L ? T : BuildTuple; +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) +>L : Symbol(L, Decl(excessivelyLargeTupleSpread.ts, 2, 16)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) +>BuildTuple : Symbol(BuildTuple, Decl(excessivelyLargeTupleSpread.ts, 0, 0)) +>L : Symbol(L, Decl(excessivelyLargeTupleSpread.ts, 2, 16)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) + +type A = BuildTuple<3> +>A : Symbol(A, Decl(excessivelyLargeTupleSpread.ts, 3, 60)) +>BuildTuple : Symbol(BuildTuple, Decl(excessivelyLargeTupleSpread.ts, 0, 0)) + +type T0 = [any]; +>T0 : Symbol(T0, Decl(excessivelyLargeTupleSpread.ts, 5, 22)) + +type T1 = [...T0, ...T0]; +>T1 : Symbol(T1, Decl(excessivelyLargeTupleSpread.ts, 7, 16)) +>T0 : Symbol(T0, Decl(excessivelyLargeTupleSpread.ts, 5, 22)) +>T0 : Symbol(T0, Decl(excessivelyLargeTupleSpread.ts, 5, 22)) + +type T2 = [...T1, ...T1]; +>T2 : Symbol(T2, Decl(excessivelyLargeTupleSpread.ts, 8, 25)) +>T1 : Symbol(T1, Decl(excessivelyLargeTupleSpread.ts, 7, 16)) +>T1 : Symbol(T1, Decl(excessivelyLargeTupleSpread.ts, 7, 16)) + +type T3 = [...T2, ...T2]; +>T3 : Symbol(T3, Decl(excessivelyLargeTupleSpread.ts, 9, 25)) +>T2 : Symbol(T2, Decl(excessivelyLargeTupleSpread.ts, 8, 25)) +>T2 : Symbol(T2, Decl(excessivelyLargeTupleSpread.ts, 8, 25)) + +type T4 = [...T3, ...T3]; +>T4 : Symbol(T4, Decl(excessivelyLargeTupleSpread.ts, 10, 25)) +>T3 : Symbol(T3, Decl(excessivelyLargeTupleSpread.ts, 9, 25)) +>T3 : Symbol(T3, Decl(excessivelyLargeTupleSpread.ts, 9, 25)) + +type T5 = [...T4, ...T4]; +>T5 : Symbol(T5, Decl(excessivelyLargeTupleSpread.ts, 11, 25)) +>T4 : Symbol(T4, Decl(excessivelyLargeTupleSpread.ts, 10, 25)) +>T4 : Symbol(T4, Decl(excessivelyLargeTupleSpread.ts, 10, 25)) + +type T6 = [...T5, ...T5]; +>T6 : Symbol(T6, Decl(excessivelyLargeTupleSpread.ts, 12, 25)) +>T5 : Symbol(T5, Decl(excessivelyLargeTupleSpread.ts, 11, 25)) +>T5 : Symbol(T5, Decl(excessivelyLargeTupleSpread.ts, 11, 25)) + +type T7 = [...T6, ...T6]; +>T7 : Symbol(T7, Decl(excessivelyLargeTupleSpread.ts, 13, 25)) +>T6 : Symbol(T6, Decl(excessivelyLargeTupleSpread.ts, 12, 25)) +>T6 : Symbol(T6, Decl(excessivelyLargeTupleSpread.ts, 12, 25)) + +type T8 = [...T7, ...T7]; +>T8 : Symbol(T8, Decl(excessivelyLargeTupleSpread.ts, 14, 25)) +>T7 : Symbol(T7, Decl(excessivelyLargeTupleSpread.ts, 13, 25)) +>T7 : Symbol(T7, Decl(excessivelyLargeTupleSpread.ts, 13, 25)) + +type T9 = [...T8, ...T8]; +>T9 : Symbol(T9, Decl(excessivelyLargeTupleSpread.ts, 15, 25)) +>T8 : Symbol(T8, Decl(excessivelyLargeTupleSpread.ts, 14, 25)) +>T8 : Symbol(T8, Decl(excessivelyLargeTupleSpread.ts, 14, 25)) + +type T10 = [...T9, ...T9]; +>T10 : Symbol(T10, Decl(excessivelyLargeTupleSpread.ts, 16, 25)) +>T9 : Symbol(T9, Decl(excessivelyLargeTupleSpread.ts, 15, 25)) +>T9 : Symbol(T9, Decl(excessivelyLargeTupleSpread.ts, 15, 25)) + +type T11 = [...T10, ...T10]; +>T11 : Symbol(T11, Decl(excessivelyLargeTupleSpread.ts, 17, 26)) +>T10 : Symbol(T10, Decl(excessivelyLargeTupleSpread.ts, 16, 25)) +>T10 : Symbol(T10, Decl(excessivelyLargeTupleSpread.ts, 16, 25)) + +type T12 = [...T11, ...T11]; +>T12 : Symbol(T12, Decl(excessivelyLargeTupleSpread.ts, 18, 28)) +>T11 : Symbol(T11, Decl(excessivelyLargeTupleSpread.ts, 17, 26)) +>T11 : Symbol(T11, Decl(excessivelyLargeTupleSpread.ts, 17, 26)) + +type T13 = [...T12, ...T12]; +>T13 : Symbol(T13, Decl(excessivelyLargeTupleSpread.ts, 19, 28)) +>T12 : Symbol(T12, Decl(excessivelyLargeTupleSpread.ts, 18, 28)) +>T12 : Symbol(T12, Decl(excessivelyLargeTupleSpread.ts, 18, 28)) + +type T14 = [...T13, ...T13]; // 2^14 > 10,000 +>T14 : Symbol(T14, Decl(excessivelyLargeTupleSpread.ts, 20, 28)) +>T13 : Symbol(T13, Decl(excessivelyLargeTupleSpread.ts, 19, 28)) +>T13 : Symbol(T13, Decl(excessivelyLargeTupleSpread.ts, 19, 28)) + +const a0 = [0] as const; +>a0 : Symbol(a0, Decl(excessivelyLargeTupleSpread.ts, 23, 5)) +>const : Symbol(const) + +const a1 = [...a0, ...a0] as const; +>a1 : Symbol(a1, Decl(excessivelyLargeTupleSpread.ts, 24, 5)) +>a0 : Symbol(a0, Decl(excessivelyLargeTupleSpread.ts, 23, 5)) +>a0 : Symbol(a0, Decl(excessivelyLargeTupleSpread.ts, 23, 5)) +>const : Symbol(const) + +const a2 = [...a1, ...a1] as const; +>a2 : Symbol(a2, Decl(excessivelyLargeTupleSpread.ts, 25, 5)) +>a1 : Symbol(a1, Decl(excessivelyLargeTupleSpread.ts, 24, 5)) +>a1 : Symbol(a1, Decl(excessivelyLargeTupleSpread.ts, 24, 5)) +>const : Symbol(const) + +const a3 = [...a2, ...a2] as const; +>a3 : Symbol(a3, Decl(excessivelyLargeTupleSpread.ts, 26, 5)) +>a2 : Symbol(a2, Decl(excessivelyLargeTupleSpread.ts, 25, 5)) +>a2 : Symbol(a2, Decl(excessivelyLargeTupleSpread.ts, 25, 5)) +>const : Symbol(const) + +const a4 = [...a3, ...a3] as const; +>a4 : Symbol(a4, Decl(excessivelyLargeTupleSpread.ts, 27, 5)) +>a3 : Symbol(a3, Decl(excessivelyLargeTupleSpread.ts, 26, 5)) +>a3 : Symbol(a3, Decl(excessivelyLargeTupleSpread.ts, 26, 5)) +>const : Symbol(const) + +const a5 = [...a4, ...a4] as const; +>a5 : Symbol(a5, Decl(excessivelyLargeTupleSpread.ts, 28, 5)) +>a4 : Symbol(a4, Decl(excessivelyLargeTupleSpread.ts, 27, 5)) +>a4 : Symbol(a4, Decl(excessivelyLargeTupleSpread.ts, 27, 5)) +>const : Symbol(const) + +const a6 = [...a5, ...a5] as const; +>a6 : Symbol(a6, Decl(excessivelyLargeTupleSpread.ts, 29, 5)) +>a5 : Symbol(a5, Decl(excessivelyLargeTupleSpread.ts, 28, 5)) +>a5 : Symbol(a5, Decl(excessivelyLargeTupleSpread.ts, 28, 5)) +>const : Symbol(const) + +const a7 = [...a6, ...a6] as const; +>a7 : Symbol(a7, Decl(excessivelyLargeTupleSpread.ts, 30, 5)) +>a6 : Symbol(a6, Decl(excessivelyLargeTupleSpread.ts, 29, 5)) +>a6 : Symbol(a6, Decl(excessivelyLargeTupleSpread.ts, 29, 5)) +>const : Symbol(const) + +const a8 = [...a7, ...a7] as const; +>a8 : Symbol(a8, Decl(excessivelyLargeTupleSpread.ts, 31, 5)) +>a7 : Symbol(a7, Decl(excessivelyLargeTupleSpread.ts, 30, 5)) +>a7 : Symbol(a7, Decl(excessivelyLargeTupleSpread.ts, 30, 5)) +>const : Symbol(const) + +const a9 = [...a8, ...a8] as const; +>a9 : Symbol(a9, Decl(excessivelyLargeTupleSpread.ts, 32, 5)) +>a8 : Symbol(a8, Decl(excessivelyLargeTupleSpread.ts, 31, 5)) +>a8 : Symbol(a8, Decl(excessivelyLargeTupleSpread.ts, 31, 5)) +>const : Symbol(const) + +const a10 = [...a9, ...a9] as const; +>a10 : Symbol(a10, Decl(excessivelyLargeTupleSpread.ts, 33, 5)) +>a9 : Symbol(a9, Decl(excessivelyLargeTupleSpread.ts, 32, 5)) +>a9 : Symbol(a9, Decl(excessivelyLargeTupleSpread.ts, 32, 5)) +>const : Symbol(const) + +const a11 = [...a10, ...a10] as const; +>a11 : Symbol(a11, Decl(excessivelyLargeTupleSpread.ts, 34, 5)) +>a10 : Symbol(a10, Decl(excessivelyLargeTupleSpread.ts, 33, 5)) +>a10 : Symbol(a10, Decl(excessivelyLargeTupleSpread.ts, 33, 5)) +>const : Symbol(const) + +const a12 = [...a11, ...a11] as const; +>a12 : Symbol(a12, Decl(excessivelyLargeTupleSpread.ts, 35, 5)) +>a11 : Symbol(a11, Decl(excessivelyLargeTupleSpread.ts, 34, 5)) +>a11 : Symbol(a11, Decl(excessivelyLargeTupleSpread.ts, 34, 5)) +>const : Symbol(const) + +const a13 = [...a12, ...a12] as const; +>a13 : Symbol(a13, Decl(excessivelyLargeTupleSpread.ts, 36, 5)) +>a12 : Symbol(a12, Decl(excessivelyLargeTupleSpread.ts, 35, 5)) +>a12 : Symbol(a12, Decl(excessivelyLargeTupleSpread.ts, 35, 5)) +>const : Symbol(const) + +const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 +>a14 : Symbol(a14, Decl(excessivelyLargeTupleSpread.ts, 37, 5)) +>a13 : Symbol(a13, Decl(excessivelyLargeTupleSpread.ts, 36, 5)) +>a13 : Symbol(a13, Decl(excessivelyLargeTupleSpread.ts, 36, 5)) +>const : Symbol(const) + diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).types new file mode 100644 index 0000000000000..beb6075368e3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).types @@ -0,0 +1,190 @@ +//// [tests/cases/compiler/excessivelyLargeTupleSpread.ts] //// + +=== excessivelyLargeTupleSpread.ts === +// #41771 + +type BuildTuple = +>BuildTuple : BuildTuple + + T['length'] extends L ? T : BuildTuple; + +type A = BuildTuple<3> +>A : any + +type T0 = [any]; +>T0 : T0 + +type T1 = [...T0, ...T0]; +>T1 : [any, any] + +type T2 = [...T1, ...T1]; +>T2 : [any, any, any, any] + +type T3 = [...T2, ...T2]; +>T3 : [any, any, any, any, any, any, any, any] + +type T4 = [...T3, ...T3]; +>T4 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T5 = [...T4, ...T4]; +>T5 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T6 = [...T5, ...T5]; +>T6 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T7 = [...T6, ...T6]; +>T7 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T8 = [...T7, ...T7]; +>T8 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T9 = [...T8, ...T8]; +>T9 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T10 = [...T9, ...T9]; +>T10 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T11 = [...T10, ...T10]; +>T11 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T12 = [...T11, ...T11]; +>T12 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T13 = [...T12, ...T12]; +>T13 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T14 = [...T13, ...T13]; // 2^14 > 10,000 +>T14 : any + +const a0 = [0] as const; +>a0 : readonly [0] +>[0] as const : readonly [0] +>[0] : readonly [0] +>0 : 0 + +const a1 = [...a0, ...a0] as const; +>a1 : readonly [0, 0] +>[...a0, ...a0] as const : readonly [0, 0] +>[...a0, ...a0] : readonly [0, 0] +>...a0 : 0 +>a0 : readonly [0] +>...a0 : 0 +>a0 : readonly [0] + +const a2 = [...a1, ...a1] as const; +>a2 : readonly [0, 0, 0, 0] +>[...a1, ...a1] as const : readonly [0, 0, 0, 0] +>[...a1, ...a1] : readonly [0, 0, 0, 0] +>...a1 : 0 +>a1 : readonly [0, 0] +>...a1 : 0 +>a1 : readonly [0, 0] + +const a3 = [...a2, ...a2] as const; +>a3 : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>[...a2, ...a2] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>[...a2, ...a2] : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>...a2 : 0 +>a2 : readonly [0, 0, 0, 0] +>...a2 : 0 +>a2 : readonly [0, 0, 0, 0] + +const a4 = [...a3, ...a3] as const; +>a4 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a3, ...a3] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a3, ...a3] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a3 : 0 +>a3 : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>...a3 : 0 +>a3 : readonly [0, 0, 0, 0, 0, 0, 0, 0] + +const a5 = [...a4, ...a4] as const; +>a5 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a4, ...a4] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a4, ...a4] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a4 : 0 +>a4 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a4 : 0 +>a4 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a6 = [...a5, ...a5] as const; +>a6 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a5, ...a5] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a5, ...a5] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a5 : 0 +>a5 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a5 : 0 +>a5 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a7 = [...a6, ...a6] as const; +>a7 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a6, ...a6] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a6, ...a6] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a6 : 0 +>a6 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a6 : 0 +>a6 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a8 = [...a7, ...a7] as const; +>a8 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a7, ...a7] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a7, ...a7] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a7 : 0 +>a7 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a7 : 0 +>a7 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a9 = [...a8, ...a8] as const; +>a9 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a8, ...a8] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a8, ...a8] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a8 : 0 +>a8 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a8 : 0 +>a8 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a10 = [...a9, ...a9] as const; +>a10 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a9, ...a9] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a9, ...a9] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a9 : 0 +>a9 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a9 : 0 +>a9 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a11 = [...a10, ...a10] as const; +>a11 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a10, ...a10] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a10, ...a10] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a10 : 0 +>a10 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a10 : 0 +>a10 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a12 = [...a11, ...a11] as const; +>a12 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a11, ...a11] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a11, ...a11] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a11 : 0 +>a11 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a11 : 0 +>a11 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a13 = [...a12, ...a12] as const; +>a13 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a12, ...a12] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a12, ...a12] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a12 : 0 +>a12 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a12 : 0 +>a12 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 +>a14 : any +>[...a13, ...a13] as const : any +>[...a13, ...a13] : any +>...a13 : 0 +>a13 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a13 : 0 +>a13 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..6ec6fc6629d8a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt @@ -0,0 +1,51 @@ +excessivelyLargeTupleSpread.ts(6,10): error TS2799: Type produces a tuple type that is too large to represent. +excessivelyLargeTupleSpread.ts(22,12): error TS2799: Type produces a tuple type that is too large to represent. +excessivelyLargeTupleSpread.ts(38,13): error TS2800: Expression produces a tuple type that is too large to represent. + + +==== excessivelyLargeTupleSpread.ts (3 errors) ==== + // #41771 + + type BuildTuple = + T['length'] extends L ? T : BuildTuple; + + type A = BuildTuple<3> + ~~~~~~~~~~~~~ +!!! error TS2799: Type produces a tuple type that is too large to represent. + + type T0 = [any]; + type T1 = [...T0, ...T0]; + type T2 = [...T1, ...T1]; + type T3 = [...T2, ...T2]; + type T4 = [...T3, ...T3]; + type T5 = [...T4, ...T4]; + type T6 = [...T5, ...T5]; + type T7 = [...T6, ...T6]; + type T8 = [...T7, ...T7]; + type T9 = [...T8, ...T8]; + type T10 = [...T9, ...T9]; + type T11 = [...T10, ...T10]; + type T12 = [...T11, ...T11]; + type T13 = [...T12, ...T12]; + type T14 = [...T13, ...T13]; // 2^14 > 10,000 + ~~~~~~~~~~~~~~~~ +!!! error TS2799: Type produces a tuple type that is too large to represent. + + const a0 = [0] as const; + const a1 = [...a0, ...a0] as const; + const a2 = [...a1, ...a1] as const; + const a3 = [...a2, ...a2] as const; + const a4 = [...a3, ...a3] as const; + const a5 = [...a4, ...a4] as const; + const a6 = [...a5, ...a5] as const; + const a7 = [...a6, ...a6] as const; + const a8 = [...a7, ...a7] as const; + const a9 = [...a8, ...a8] as const; + const a10 = [...a9, ...a9] as const; + const a11 = [...a10, ...a10] as const; + const a12 = [...a11, ...a11] as const; + const a13 = [...a12, ...a12] as const; + const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 + ~~~~~~~~~~~~~~~~ +!!! error TS2800: Expression produces a tuple type that is too large to represent. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).js new file mode 100644 index 0000000000000..bbb96dcc93129 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).js @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/excessivelyLargeTupleSpread.ts] //// + +//// [excessivelyLargeTupleSpread.ts] +// #41771 + +type BuildTuple = + T['length'] extends L ? T : BuildTuple; + +type A = BuildTuple<3> + +type T0 = [any]; +type T1 = [...T0, ...T0]; +type T2 = [...T1, ...T1]; +type T3 = [...T2, ...T2]; +type T4 = [...T3, ...T3]; +type T5 = [...T4, ...T4]; +type T6 = [...T5, ...T5]; +type T7 = [...T6, ...T6]; +type T8 = [...T7, ...T7]; +type T9 = [...T8, ...T8]; +type T10 = [...T9, ...T9]; +type T11 = [...T10, ...T10]; +type T12 = [...T11, ...T11]; +type T13 = [...T12, ...T12]; +type T14 = [...T13, ...T13]; // 2^14 > 10,000 + +const a0 = [0] as const; +const a1 = [...a0, ...a0] as const; +const a2 = [...a1, ...a1] as const; +const a3 = [...a2, ...a2] as const; +const a4 = [...a3, ...a3] as const; +const a5 = [...a4, ...a4] as const; +const a6 = [...a5, ...a5] as const; +const a7 = [...a6, ...a6] as const; +const a8 = [...a7, ...a7] as const; +const a9 = [...a8, ...a8] as const; +const a10 = [...a9, ...a9] as const; +const a11 = [...a10, ...a10] as const; +const a12 = [...a11, ...a11] as const; +const a13 = [...a12, ...a12] as const; +const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 + + +//// [excessivelyLargeTupleSpread.js] +"use strict"; +// #41771 +const a0 = [0]; +const a1 = [...a0, ...a0]; +const a2 = [...a1, ...a1]; +const a3 = [...a2, ...a2]; +const a4 = [...a3, ...a3]; +const a5 = [...a4, ...a4]; +const a6 = [...a5, ...a5]; +const a7 = [...a6, ...a6]; +const a8 = [...a7, ...a7]; +const a9 = [...a8, ...a8]; +const a10 = [...a9, ...a9]; +const a11 = [...a10, ...a10]; +const a12 = [...a11, ...a11]; +const a13 = [...a12, ...a12]; +const a14 = [...a13, ...a13]; // 2^14 > 10,000 diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..629d43f9085cf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).symbols @@ -0,0 +1,184 @@ +//// [tests/cases/compiler/excessivelyLargeTupleSpread.ts] //// + +=== excessivelyLargeTupleSpread.ts === +// #41771 + +type BuildTuple = +>BuildTuple : Symbol(BuildTuple, Decl(excessivelyLargeTupleSpread.ts, 0, 0)) +>L : Symbol(L, Decl(excessivelyLargeTupleSpread.ts, 2, 16)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) + + T['length'] extends L ? T : BuildTuple; +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) +>L : Symbol(L, Decl(excessivelyLargeTupleSpread.ts, 2, 16)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) +>BuildTuple : Symbol(BuildTuple, Decl(excessivelyLargeTupleSpread.ts, 0, 0)) +>L : Symbol(L, Decl(excessivelyLargeTupleSpread.ts, 2, 16)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) +>T : Symbol(T, Decl(excessivelyLargeTupleSpread.ts, 2, 33)) + +type A = BuildTuple<3> +>A : Symbol(A, Decl(excessivelyLargeTupleSpread.ts, 3, 60)) +>BuildTuple : Symbol(BuildTuple, Decl(excessivelyLargeTupleSpread.ts, 0, 0)) + +type T0 = [any]; +>T0 : Symbol(T0, Decl(excessivelyLargeTupleSpread.ts, 5, 22)) + +type T1 = [...T0, ...T0]; +>T1 : Symbol(T1, Decl(excessivelyLargeTupleSpread.ts, 7, 16)) +>T0 : Symbol(T0, Decl(excessivelyLargeTupleSpread.ts, 5, 22)) +>T0 : Symbol(T0, Decl(excessivelyLargeTupleSpread.ts, 5, 22)) + +type T2 = [...T1, ...T1]; +>T2 : Symbol(T2, Decl(excessivelyLargeTupleSpread.ts, 8, 25)) +>T1 : Symbol(T1, Decl(excessivelyLargeTupleSpread.ts, 7, 16)) +>T1 : Symbol(T1, Decl(excessivelyLargeTupleSpread.ts, 7, 16)) + +type T3 = [...T2, ...T2]; +>T3 : Symbol(T3, Decl(excessivelyLargeTupleSpread.ts, 9, 25)) +>T2 : Symbol(T2, Decl(excessivelyLargeTupleSpread.ts, 8, 25)) +>T2 : Symbol(T2, Decl(excessivelyLargeTupleSpread.ts, 8, 25)) + +type T4 = [...T3, ...T3]; +>T4 : Symbol(T4, Decl(excessivelyLargeTupleSpread.ts, 10, 25)) +>T3 : Symbol(T3, Decl(excessivelyLargeTupleSpread.ts, 9, 25)) +>T3 : Symbol(T3, Decl(excessivelyLargeTupleSpread.ts, 9, 25)) + +type T5 = [...T4, ...T4]; +>T5 : Symbol(T5, Decl(excessivelyLargeTupleSpread.ts, 11, 25)) +>T4 : Symbol(T4, Decl(excessivelyLargeTupleSpread.ts, 10, 25)) +>T4 : Symbol(T4, Decl(excessivelyLargeTupleSpread.ts, 10, 25)) + +type T6 = [...T5, ...T5]; +>T6 : Symbol(T6, Decl(excessivelyLargeTupleSpread.ts, 12, 25)) +>T5 : Symbol(T5, Decl(excessivelyLargeTupleSpread.ts, 11, 25)) +>T5 : Symbol(T5, Decl(excessivelyLargeTupleSpread.ts, 11, 25)) + +type T7 = [...T6, ...T6]; +>T7 : Symbol(T7, Decl(excessivelyLargeTupleSpread.ts, 13, 25)) +>T6 : Symbol(T6, Decl(excessivelyLargeTupleSpread.ts, 12, 25)) +>T6 : Symbol(T6, Decl(excessivelyLargeTupleSpread.ts, 12, 25)) + +type T8 = [...T7, ...T7]; +>T8 : Symbol(T8, Decl(excessivelyLargeTupleSpread.ts, 14, 25)) +>T7 : Symbol(T7, Decl(excessivelyLargeTupleSpread.ts, 13, 25)) +>T7 : Symbol(T7, Decl(excessivelyLargeTupleSpread.ts, 13, 25)) + +type T9 = [...T8, ...T8]; +>T9 : Symbol(T9, Decl(excessivelyLargeTupleSpread.ts, 15, 25)) +>T8 : Symbol(T8, Decl(excessivelyLargeTupleSpread.ts, 14, 25)) +>T8 : Symbol(T8, Decl(excessivelyLargeTupleSpread.ts, 14, 25)) + +type T10 = [...T9, ...T9]; +>T10 : Symbol(T10, Decl(excessivelyLargeTupleSpread.ts, 16, 25)) +>T9 : Symbol(T9, Decl(excessivelyLargeTupleSpread.ts, 15, 25)) +>T9 : Symbol(T9, Decl(excessivelyLargeTupleSpread.ts, 15, 25)) + +type T11 = [...T10, ...T10]; +>T11 : Symbol(T11, Decl(excessivelyLargeTupleSpread.ts, 17, 26)) +>T10 : Symbol(T10, Decl(excessivelyLargeTupleSpread.ts, 16, 25)) +>T10 : Symbol(T10, Decl(excessivelyLargeTupleSpread.ts, 16, 25)) + +type T12 = [...T11, ...T11]; +>T12 : Symbol(T12, Decl(excessivelyLargeTupleSpread.ts, 18, 28)) +>T11 : Symbol(T11, Decl(excessivelyLargeTupleSpread.ts, 17, 26)) +>T11 : Symbol(T11, Decl(excessivelyLargeTupleSpread.ts, 17, 26)) + +type T13 = [...T12, ...T12]; +>T13 : Symbol(T13, Decl(excessivelyLargeTupleSpread.ts, 19, 28)) +>T12 : Symbol(T12, Decl(excessivelyLargeTupleSpread.ts, 18, 28)) +>T12 : Symbol(T12, Decl(excessivelyLargeTupleSpread.ts, 18, 28)) + +type T14 = [...T13, ...T13]; // 2^14 > 10,000 +>T14 : Symbol(T14, Decl(excessivelyLargeTupleSpread.ts, 20, 28)) +>T13 : Symbol(T13, Decl(excessivelyLargeTupleSpread.ts, 19, 28)) +>T13 : Symbol(T13, Decl(excessivelyLargeTupleSpread.ts, 19, 28)) + +const a0 = [0] as const; +>a0 : Symbol(a0, Decl(excessivelyLargeTupleSpread.ts, 23, 5)) +>const : Symbol(const) + +const a1 = [...a0, ...a0] as const; +>a1 : Symbol(a1, Decl(excessivelyLargeTupleSpread.ts, 24, 5)) +>a0 : Symbol(a0, Decl(excessivelyLargeTupleSpread.ts, 23, 5)) +>a0 : Symbol(a0, Decl(excessivelyLargeTupleSpread.ts, 23, 5)) +>const : Symbol(const) + +const a2 = [...a1, ...a1] as const; +>a2 : Symbol(a2, Decl(excessivelyLargeTupleSpread.ts, 25, 5)) +>a1 : Symbol(a1, Decl(excessivelyLargeTupleSpread.ts, 24, 5)) +>a1 : Symbol(a1, Decl(excessivelyLargeTupleSpread.ts, 24, 5)) +>const : Symbol(const) + +const a3 = [...a2, ...a2] as const; +>a3 : Symbol(a3, Decl(excessivelyLargeTupleSpread.ts, 26, 5)) +>a2 : Symbol(a2, Decl(excessivelyLargeTupleSpread.ts, 25, 5)) +>a2 : Symbol(a2, Decl(excessivelyLargeTupleSpread.ts, 25, 5)) +>const : Symbol(const) + +const a4 = [...a3, ...a3] as const; +>a4 : Symbol(a4, Decl(excessivelyLargeTupleSpread.ts, 27, 5)) +>a3 : Symbol(a3, Decl(excessivelyLargeTupleSpread.ts, 26, 5)) +>a3 : Symbol(a3, Decl(excessivelyLargeTupleSpread.ts, 26, 5)) +>const : Symbol(const) + +const a5 = [...a4, ...a4] as const; +>a5 : Symbol(a5, Decl(excessivelyLargeTupleSpread.ts, 28, 5)) +>a4 : Symbol(a4, Decl(excessivelyLargeTupleSpread.ts, 27, 5)) +>a4 : Symbol(a4, Decl(excessivelyLargeTupleSpread.ts, 27, 5)) +>const : Symbol(const) + +const a6 = [...a5, ...a5] as const; +>a6 : Symbol(a6, Decl(excessivelyLargeTupleSpread.ts, 29, 5)) +>a5 : Symbol(a5, Decl(excessivelyLargeTupleSpread.ts, 28, 5)) +>a5 : Symbol(a5, Decl(excessivelyLargeTupleSpread.ts, 28, 5)) +>const : Symbol(const) + +const a7 = [...a6, ...a6] as const; +>a7 : Symbol(a7, Decl(excessivelyLargeTupleSpread.ts, 30, 5)) +>a6 : Symbol(a6, Decl(excessivelyLargeTupleSpread.ts, 29, 5)) +>a6 : Symbol(a6, Decl(excessivelyLargeTupleSpread.ts, 29, 5)) +>const : Symbol(const) + +const a8 = [...a7, ...a7] as const; +>a8 : Symbol(a8, Decl(excessivelyLargeTupleSpread.ts, 31, 5)) +>a7 : Symbol(a7, Decl(excessivelyLargeTupleSpread.ts, 30, 5)) +>a7 : Symbol(a7, Decl(excessivelyLargeTupleSpread.ts, 30, 5)) +>const : Symbol(const) + +const a9 = [...a8, ...a8] as const; +>a9 : Symbol(a9, Decl(excessivelyLargeTupleSpread.ts, 32, 5)) +>a8 : Symbol(a8, Decl(excessivelyLargeTupleSpread.ts, 31, 5)) +>a8 : Symbol(a8, Decl(excessivelyLargeTupleSpread.ts, 31, 5)) +>const : Symbol(const) + +const a10 = [...a9, ...a9] as const; +>a10 : Symbol(a10, Decl(excessivelyLargeTupleSpread.ts, 33, 5)) +>a9 : Symbol(a9, Decl(excessivelyLargeTupleSpread.ts, 32, 5)) +>a9 : Symbol(a9, Decl(excessivelyLargeTupleSpread.ts, 32, 5)) +>const : Symbol(const) + +const a11 = [...a10, ...a10] as const; +>a11 : Symbol(a11, Decl(excessivelyLargeTupleSpread.ts, 34, 5)) +>a10 : Symbol(a10, Decl(excessivelyLargeTupleSpread.ts, 33, 5)) +>a10 : Symbol(a10, Decl(excessivelyLargeTupleSpread.ts, 33, 5)) +>const : Symbol(const) + +const a12 = [...a11, ...a11] as const; +>a12 : Symbol(a12, Decl(excessivelyLargeTupleSpread.ts, 35, 5)) +>a11 : Symbol(a11, Decl(excessivelyLargeTupleSpread.ts, 34, 5)) +>a11 : Symbol(a11, Decl(excessivelyLargeTupleSpread.ts, 34, 5)) +>const : Symbol(const) + +const a13 = [...a12, ...a12] as const; +>a13 : Symbol(a13, Decl(excessivelyLargeTupleSpread.ts, 36, 5)) +>a12 : Symbol(a12, Decl(excessivelyLargeTupleSpread.ts, 35, 5)) +>a12 : Symbol(a12, Decl(excessivelyLargeTupleSpread.ts, 35, 5)) +>const : Symbol(const) + +const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 +>a14 : Symbol(a14, Decl(excessivelyLargeTupleSpread.ts, 37, 5)) +>a13 : Symbol(a13, Decl(excessivelyLargeTupleSpread.ts, 36, 5)) +>a13 : Symbol(a13, Decl(excessivelyLargeTupleSpread.ts, 36, 5)) +>const : Symbol(const) + diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).types new file mode 100644 index 0000000000000..beb6075368e3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).types @@ -0,0 +1,190 @@ +//// [tests/cases/compiler/excessivelyLargeTupleSpread.ts] //// + +=== excessivelyLargeTupleSpread.ts === +// #41771 + +type BuildTuple = +>BuildTuple : BuildTuple + + T['length'] extends L ? T : BuildTuple; + +type A = BuildTuple<3> +>A : any + +type T0 = [any]; +>T0 : T0 + +type T1 = [...T0, ...T0]; +>T1 : [any, any] + +type T2 = [...T1, ...T1]; +>T2 : [any, any, any, any] + +type T3 = [...T2, ...T2]; +>T3 : [any, any, any, any, any, any, any, any] + +type T4 = [...T3, ...T3]; +>T4 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T5 = [...T4, ...T4]; +>T5 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T6 = [...T5, ...T5]; +>T6 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T7 = [...T6, ...T6]; +>T7 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T8 = [...T7, ...T7]; +>T8 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T9 = [...T8, ...T8]; +>T9 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T10 = [...T9, ...T9]; +>T10 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T11 = [...T10, ...T10]; +>T11 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T12 = [...T11, ...T11]; +>T12 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T13 = [...T12, ...T12]; +>T13 : [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +type T14 = [...T13, ...T13]; // 2^14 > 10,000 +>T14 : any + +const a0 = [0] as const; +>a0 : readonly [0] +>[0] as const : readonly [0] +>[0] : readonly [0] +>0 : 0 + +const a1 = [...a0, ...a0] as const; +>a1 : readonly [0, 0] +>[...a0, ...a0] as const : readonly [0, 0] +>[...a0, ...a0] : readonly [0, 0] +>...a0 : 0 +>a0 : readonly [0] +>...a0 : 0 +>a0 : readonly [0] + +const a2 = [...a1, ...a1] as const; +>a2 : readonly [0, 0, 0, 0] +>[...a1, ...a1] as const : readonly [0, 0, 0, 0] +>[...a1, ...a1] : readonly [0, 0, 0, 0] +>...a1 : 0 +>a1 : readonly [0, 0] +>...a1 : 0 +>a1 : readonly [0, 0] + +const a3 = [...a2, ...a2] as const; +>a3 : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>[...a2, ...a2] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>[...a2, ...a2] : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>...a2 : 0 +>a2 : readonly [0, 0, 0, 0] +>...a2 : 0 +>a2 : readonly [0, 0, 0, 0] + +const a4 = [...a3, ...a3] as const; +>a4 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a3, ...a3] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a3, ...a3] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a3 : 0 +>a3 : readonly [0, 0, 0, 0, 0, 0, 0, 0] +>...a3 : 0 +>a3 : readonly [0, 0, 0, 0, 0, 0, 0, 0] + +const a5 = [...a4, ...a4] as const; +>a5 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a4, ...a4] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a4, ...a4] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a4 : 0 +>a4 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a4 : 0 +>a4 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a6 = [...a5, ...a5] as const; +>a6 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a5, ...a5] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a5, ...a5] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a5 : 0 +>a5 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a5 : 0 +>a5 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a7 = [...a6, ...a6] as const; +>a7 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a6, ...a6] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a6, ...a6] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a6 : 0 +>a6 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a6 : 0 +>a6 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a8 = [...a7, ...a7] as const; +>a8 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a7, ...a7] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a7, ...a7] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a7 : 0 +>a7 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a7 : 0 +>a7 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a9 = [...a8, ...a8] as const; +>a9 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a8, ...a8] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a8, ...a8] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a8 : 0 +>a8 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a8 : 0 +>a8 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a10 = [...a9, ...a9] as const; +>a10 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a9, ...a9] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a9, ...a9] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a9 : 0 +>a9 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a9 : 0 +>a9 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a11 = [...a10, ...a10] as const; +>a11 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a10, ...a10] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a10, ...a10] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a10 : 0 +>a10 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a10 : 0 +>a10 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a12 = [...a11, ...a11] as const; +>a12 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a11, ...a11] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a11, ...a11] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a11 : 0 +>a11 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a11 : 0 +>a11 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a13 = [...a12, ...a12] as const; +>a13 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a12, ...a12] as const : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>[...a12, ...a12] : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a12 : 0 +>a12 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a12 : 0 +>a12 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + +const a14 = [...a13, ...a13] as const; // 2^14 > 10,000 +>a14 : any +>[...a13, ...a13] as const : any +>[...a13, ...a13] : any +>...a13 : 0 +>a13 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +>...a13 : 0 +>a13 : readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).errors.txt new file mode 100644 index 0000000000000..a309088cfbee7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).errors.txt @@ -0,0 +1,43 @@ +exhaustiveSwitchCheckCircularity.ts(14,26): error TS2345: Argument of type '"bbb"' is not assignable to parameter of type 'never'. + + +==== exhaustiveSwitchCheckCircularity.ts (1 errors) ==== + // Repro from #47539 + + declare function isNever(n: never): boolean; + + function f() { + let foo: "aaa" | "bbb" = "aaa"; + while (true) { + switch (foo) { + case "aaa": + } + if (foo === "aaa") { + foo = "bbb"; + } + else if (isNever(foo)) { // Error expected + ~~~ +!!! error TS2345: Argument of type '"bbb"' is not assignable to parameter of type 'never'. + break; + } + } + } + + // Repro from #51688 + + declare function functionB(key: string): string; + + function functionC(): void { + let unionVal: "A" | "B" = "A"; + while (true) { + let key: string; + switch (unionVal) { + case "A": { + key = "AA"; + break; + } + } + functionB(key); + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).js new file mode 100644 index 0000000000000..8357fd67e0c74 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).js @@ -0,0 +1,71 @@ +//// [tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts] //// + +//// [exhaustiveSwitchCheckCircularity.ts] +// Repro from #47539 + +declare function isNever(n: never): boolean; + +function f() { + let foo: "aaa" | "bbb" = "aaa"; + while (true) { + switch (foo) { + case "aaa": + } + if (foo === "aaa") { + foo = "bbb"; + } + else if (isNever(foo)) { // Error expected + break; + } + } +} + +// Repro from #51688 + +declare function functionB(key: string): string; + +function functionC(): void { + let unionVal: "A" | "B" = "A"; + while (true) { + let key: string; + switch (unionVal) { + case "A": { + key = "AA"; + break; + } + } + functionB(key); + } +} + + +//// [exhaustiveSwitchCheckCircularity.js] +"use strict"; +// Repro from #47539 +function f() { + let foo = "aaa"; + while (true) { + switch (foo) { + case "aaa": + } + if (foo === "aaa") { + foo = "bbb"; + } + else if (isNever(foo)) { // Error expected + break; + } + } +} +function functionC() { + let unionVal = "A"; + while (true) { + let key; + switch (unionVal) { + case "A": { + key = "AA"; + break; + } + } + functionB(key); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).symbols new file mode 100644 index 0000000000000..61aad225f49ab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).symbols @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts] //// + +=== exhaustiveSwitchCheckCircularity.ts === +// Repro from #47539 + +declare function isNever(n: never): boolean; +>isNever : Symbol(isNever, Decl(exhaustiveSwitchCheckCircularity.ts, 0, 0)) +>n : Symbol(n, Decl(exhaustiveSwitchCheckCircularity.ts, 2, 25)) + +function f() { +>f : Symbol(f, Decl(exhaustiveSwitchCheckCircularity.ts, 2, 44)) + + let foo: "aaa" | "bbb" = "aaa"; +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + while (true) { + switch (foo) { +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + case "aaa": + } + if (foo === "aaa") { +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + foo = "bbb"; +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + } + else if (isNever(foo)) { // Error expected +>isNever : Symbol(isNever, Decl(exhaustiveSwitchCheckCircularity.ts, 0, 0)) +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + break; + } + } +} + +// Repro from #51688 + +declare function functionB(key: string): string; +>functionB : Symbol(functionB, Decl(exhaustiveSwitchCheckCircularity.ts, 17, 1)) +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 21, 27)) + +function functionC(): void { +>functionC : Symbol(functionC, Decl(exhaustiveSwitchCheckCircularity.ts, 21, 48)) + + let unionVal: "A" | "B" = "A"; +>unionVal : Symbol(unionVal, Decl(exhaustiveSwitchCheckCircularity.ts, 24, 7)) + + while (true) { + let key: string; +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 26, 11)) + + switch (unionVal) { +>unionVal : Symbol(unionVal, Decl(exhaustiveSwitchCheckCircularity.ts, 24, 7)) + + case "A": { + key = "AA"; +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 26, 11)) + + break; + } + } + functionB(key); +>functionB : Symbol(functionB, Decl(exhaustiveSwitchCheckCircularity.ts, 17, 1)) +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 26, 11)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).types new file mode 100644 index 0000000000000..a7b44f6811ab9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).types @@ -0,0 +1,85 @@ +//// [tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts] //// + +=== exhaustiveSwitchCheckCircularity.ts === +// Repro from #47539 + +declare function isNever(n: never): boolean; +>isNever : (n: never) => boolean +>n : never + +function f() { +>f : () => void + + let foo: "aaa" | "bbb" = "aaa"; +>foo : "aaa" | "bbb" +>"aaa" : "aaa" + + while (true) { +>true : true + + switch (foo) { +>foo : "aaa" | "bbb" + + case "aaa": +>"aaa" : "aaa" + } + if (foo === "aaa") { +>foo === "aaa" : boolean +>foo : "aaa" | "bbb" +>"aaa" : "aaa" + + foo = "bbb"; +>foo = "bbb" : "bbb" +>foo : "aaa" | "bbb" +>"bbb" : "bbb" + } + else if (isNever(foo)) { // Error expected +>isNever(foo) : boolean +>isNever : (n: never) => boolean +>foo : "bbb" + + break; + } + } +} + +// Repro from #51688 + +declare function functionB(key: string): string; +>functionB : (key: string) => string +>key : string + +function functionC(): void { +>functionC : () => void + + let unionVal: "A" | "B" = "A"; +>unionVal : "A" | "B" +>"A" : "A" + + while (true) { +>true : true + + let key: string; +>key : string + + switch (unionVal) { +>unionVal : "A" + + case "A": { +>"A" : "A" + + key = "AA"; +>key = "AA" : "AA" +>key : string +>"AA" : "AA" + + break; + } + } + functionB(key); +>functionB(key) : string +>functionB : (key: string) => string +>key : string + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..a309088cfbee7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).errors.txt @@ -0,0 +1,43 @@ +exhaustiveSwitchCheckCircularity.ts(14,26): error TS2345: Argument of type '"bbb"' is not assignable to parameter of type 'never'. + + +==== exhaustiveSwitchCheckCircularity.ts (1 errors) ==== + // Repro from #47539 + + declare function isNever(n: never): boolean; + + function f() { + let foo: "aaa" | "bbb" = "aaa"; + while (true) { + switch (foo) { + case "aaa": + } + if (foo === "aaa") { + foo = "bbb"; + } + else if (isNever(foo)) { // Error expected + ~~~ +!!! error TS2345: Argument of type '"bbb"' is not assignable to parameter of type 'never'. + break; + } + } + } + + // Repro from #51688 + + declare function functionB(key: string): string; + + function functionC(): void { + let unionVal: "A" | "B" = "A"; + while (true) { + let key: string; + switch (unionVal) { + case "A": { + key = "AA"; + break; + } + } + functionB(key); + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).js new file mode 100644 index 0000000000000..8357fd67e0c74 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).js @@ -0,0 +1,71 @@ +//// [tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts] //// + +//// [exhaustiveSwitchCheckCircularity.ts] +// Repro from #47539 + +declare function isNever(n: never): boolean; + +function f() { + let foo: "aaa" | "bbb" = "aaa"; + while (true) { + switch (foo) { + case "aaa": + } + if (foo === "aaa") { + foo = "bbb"; + } + else if (isNever(foo)) { // Error expected + break; + } + } +} + +// Repro from #51688 + +declare function functionB(key: string): string; + +function functionC(): void { + let unionVal: "A" | "B" = "A"; + while (true) { + let key: string; + switch (unionVal) { + case "A": { + key = "AA"; + break; + } + } + functionB(key); + } +} + + +//// [exhaustiveSwitchCheckCircularity.js] +"use strict"; +// Repro from #47539 +function f() { + let foo = "aaa"; + while (true) { + switch (foo) { + case "aaa": + } + if (foo === "aaa") { + foo = "bbb"; + } + else if (isNever(foo)) { // Error expected + break; + } + } +} +function functionC() { + let unionVal = "A"; + while (true) { + let key; + switch (unionVal) { + case "A": { + key = "AA"; + break; + } + } + functionB(key); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..61aad225f49ab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).symbols @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts] //// + +=== exhaustiveSwitchCheckCircularity.ts === +// Repro from #47539 + +declare function isNever(n: never): boolean; +>isNever : Symbol(isNever, Decl(exhaustiveSwitchCheckCircularity.ts, 0, 0)) +>n : Symbol(n, Decl(exhaustiveSwitchCheckCircularity.ts, 2, 25)) + +function f() { +>f : Symbol(f, Decl(exhaustiveSwitchCheckCircularity.ts, 2, 44)) + + let foo: "aaa" | "bbb" = "aaa"; +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + while (true) { + switch (foo) { +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + case "aaa": + } + if (foo === "aaa") { +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + foo = "bbb"; +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + } + else if (isNever(foo)) { // Error expected +>isNever : Symbol(isNever, Decl(exhaustiveSwitchCheckCircularity.ts, 0, 0)) +>foo : Symbol(foo, Decl(exhaustiveSwitchCheckCircularity.ts, 5, 7)) + + break; + } + } +} + +// Repro from #51688 + +declare function functionB(key: string): string; +>functionB : Symbol(functionB, Decl(exhaustiveSwitchCheckCircularity.ts, 17, 1)) +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 21, 27)) + +function functionC(): void { +>functionC : Symbol(functionC, Decl(exhaustiveSwitchCheckCircularity.ts, 21, 48)) + + let unionVal: "A" | "B" = "A"; +>unionVal : Symbol(unionVal, Decl(exhaustiveSwitchCheckCircularity.ts, 24, 7)) + + while (true) { + let key: string; +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 26, 11)) + + switch (unionVal) { +>unionVal : Symbol(unionVal, Decl(exhaustiveSwitchCheckCircularity.ts, 24, 7)) + + case "A": { + key = "AA"; +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 26, 11)) + + break; + } + } + functionB(key); +>functionB : Symbol(functionB, Decl(exhaustiveSwitchCheckCircularity.ts, 17, 1)) +>key : Symbol(key, Decl(exhaustiveSwitchCheckCircularity.ts, 26, 11)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types new file mode 100644 index 0000000000000..a7b44f6811ab9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types @@ -0,0 +1,85 @@ +//// [tests/cases/compiler/exhaustiveSwitchCheckCircularity.ts] //// + +=== exhaustiveSwitchCheckCircularity.ts === +// Repro from #47539 + +declare function isNever(n: never): boolean; +>isNever : (n: never) => boolean +>n : never + +function f() { +>f : () => void + + let foo: "aaa" | "bbb" = "aaa"; +>foo : "aaa" | "bbb" +>"aaa" : "aaa" + + while (true) { +>true : true + + switch (foo) { +>foo : "aaa" | "bbb" + + case "aaa": +>"aaa" : "aaa" + } + if (foo === "aaa") { +>foo === "aaa" : boolean +>foo : "aaa" | "bbb" +>"aaa" : "aaa" + + foo = "bbb"; +>foo = "bbb" : "bbb" +>foo : "aaa" | "bbb" +>"bbb" : "bbb" + } + else if (isNever(foo)) { // Error expected +>isNever(foo) : boolean +>isNever : (n: never) => boolean +>foo : "bbb" + + break; + } + } +} + +// Repro from #51688 + +declare function functionB(key: string): string; +>functionB : (key: string) => string +>key : string + +function functionC(): void { +>functionC : () => void + + let unionVal: "A" | "B" = "A"; +>unionVal : "A" | "B" +>"A" : "A" + + while (true) { +>true : true + + let key: string; +>key : string + + switch (unionVal) { +>unionVal : "A" + + case "A": { +>"A" : "A" + + key = "AA"; +>key = "AA" : "AA" +>key : string +>"AA" : "AA" + + break; + } + } + functionB(key); +>functionB(key) : string +>functionB : (key: string) => string +>key : string + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..7f22b20127d74 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +//// [exportAssignmentNestedVisibilityQueryOrder.ts] +namespace m { + export interface Inner { + x: number; + } + export interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.js] +"use strict"; +module.exports = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.d.ts] +declare namespace m { + interface Inner { + x: number; + } + interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..37c52594b538a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + export interface Inner { +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) + + x: number; +>x : Symbol(Inner.x, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 1, 28)) + } + export interface Outer { +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + + use: (inner: Inner) => Outer; +>use : Symbol(Outer.use, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 4, 28)) +>inner : Symbol(inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 5, 14)) +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + } +} +declare var m: { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + (): m.Outer; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) +>Outer : Symbol(m.Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + +}; +export = m; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..600dc4ebe4a28 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { + export interface Inner { + x: number; +>x : number + } + export interface Outer { + use: (inner: Inner) => Outer; +>use : (inner: Inner) => Outer +>inner : Inner + } +} +declare var m: { +>m : () => m.Outer + + (): m.Outer; +>m : any + +}; +export = m; +>m : () => m.Outer + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..7f22b20127d74 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +//// [exportAssignmentNestedVisibilityQueryOrder.ts] +namespace m { + export interface Inner { + x: number; + } + export interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.js] +"use strict"; +module.exports = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.d.ts] +declare namespace m { + interface Inner { + x: number; + } + interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..37c52594b538a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + export interface Inner { +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) + + x: number; +>x : Symbol(Inner.x, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 1, 28)) + } + export interface Outer { +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + + use: (inner: Inner) => Outer; +>use : Symbol(Outer.use, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 4, 28)) +>inner : Symbol(inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 5, 14)) +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + } +} +declare var m: { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + (): m.Outer; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) +>Outer : Symbol(m.Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + +}; +export = m; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..600dc4ebe4a28 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { + export interface Inner { + x: number; +>x : number + } + export interface Outer { + use: (inner: Inner) => Outer; +>use : (inner: Inner) => Outer +>inner : Inner + } +} +declare var m: { +>m : () => m.Outer + + (): m.Outer; +>m : any + +}; +export = m; +>m : () => m.Outer + diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).errors.txt new file mode 100644 index 0000000000000..9a04ca00910e5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).errors.txt @@ -0,0 +1,45 @@ +fallbackToBindingPatternForTypeInference.ts(2,7): error TS2345: Argument of type '({ a }: { a: any; }) => any' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ a: any; }'. +fallbackToBindingPatternForTypeInference.ts(3,7): error TS2345: Argument of type '([b, c]: [any, any]) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '[any, any]'. +fallbackToBindingPatternForTypeInference.ts(4,7): error TS2345: Argument of type '({ d: [e, f] }: { d: [any, any]; }) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ d: [any, any]; }'. +fallbackToBindingPatternForTypeInference.ts(5,7): error TS2345: Argument of type '([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '[{ g: any; }, { h: any; }]'. +fallbackToBindingPatternForTypeInference.ts(6,7): error TS2345: Argument of type '({ a, b }: { a: any; b?: number | undefined; }) => any' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ a: any; b?: number | undefined; }'. + + +==== fallbackToBindingPatternForTypeInference.ts (5 errors) ==== + declare function trans(f: (x: T) => string): number; + trans(({a}) => a); + ~~~~~~~~~~ +!!! error TS2345: Argument of type '({ a }: { a: any; }) => any' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ a: any; }'. + trans(([b,c]) => 'foo'); + ~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '([b, c]: [any, any]) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '[any, any]'. + trans(({d: [e,f]}) => 'foo'); + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '({ d: [e, f] }: { d: [any, any]; }) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ d: [any, any]; }'. + trans(([{g},{h}]) => 'foo'); + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '[{ g: any; }, { h: any; }]'. + trans(({a, b = 10}) => a); + ~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '({ a, b }: { a: any; b?: number | undefined; }) => any' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ a: any; b?: number | undefined; }'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).js new file mode 100644 index 0000000000000..60378832d9d6a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).js @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +//// [fallbackToBindingPatternForTypeInference.ts] +declare function trans(f: (x: T) => string): number; +trans(({a}) => a); +trans(([b,c]) => 'foo'); +trans(({d: [e,f]}) => 'foo'); +trans(([{g},{h}]) => 'foo'); +trans(({a, b = 10}) => a); + + +//// [fallbackToBindingPatternForTypeInference.js] +"use strict"; +trans(({ a }) => a); +trans(([b, c]) => 'foo'); +trans(({ d: [e, f] }) => 'foo'); +trans(([{ g }, { h }]) => 'foo'); +trans(({ a, b = 10 }) => a); diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).symbols new file mode 100644 index 0000000000000..7e6456be8db3c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +=== fallbackToBindingPatternForTypeInference.ts === +declare function trans(f: (x: T) => string): number; +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>T : Symbol(T, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 23)) +>f : Symbol(f, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 26)) +>x : Symbol(x, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 30)) +>T : Symbol(T, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 23)) + +trans(({a}) => a); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 1, 8)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 1, 8)) + +trans(([b,c]) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>b : Symbol(b, Decl(fallbackToBindingPatternForTypeInference.ts, 2, 8)) +>c : Symbol(c, Decl(fallbackToBindingPatternForTypeInference.ts, 2, 10)) + +trans(({d: [e,f]}) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>e : Symbol(e, Decl(fallbackToBindingPatternForTypeInference.ts, 3, 12)) +>f : Symbol(f, Decl(fallbackToBindingPatternForTypeInference.ts, 3, 14)) + +trans(([{g},{h}]) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>g : Symbol(g, Decl(fallbackToBindingPatternForTypeInference.ts, 4, 9)) +>h : Symbol(h, Decl(fallbackToBindingPatternForTypeInference.ts, 4, 13)) + +trans(({a, b = 10}) => a); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 8)) +>b : Symbol(b, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 10)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 8)) + diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).types new file mode 100644 index 0000000000000..be3950ad98131 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).types @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +=== fallbackToBindingPatternForTypeInference.ts === +declare function trans(f: (x: T) => string): number; +>trans : (f: (x: T) => string) => number +>f : (x: T) => string +>x : T + +trans(({a}) => a); +>trans(({a}) => a) : number +>trans : (f: (x: T) => string) => number +>({a}) => a : ({ a }: { a: any; }) => any +>a : any +>a : any + +trans(([b,c]) => 'foo'); +>trans(([b,c]) => 'foo') : number +>trans : (f: (x: T) => string) => number +>([b,c]) => 'foo' : ([b, c]: [any, any]) => string +>b : any +>c : any +>'foo' : "foo" + +trans(({d: [e,f]}) => 'foo'); +>trans(({d: [e,f]}) => 'foo') : number +>trans : (f: (x: T) => string) => number +>({d: [e,f]}) => 'foo' : ({ d: [e, f] }: { d: [any, any]; }) => string +>d : any +>e : any +>f : any +>'foo' : "foo" + +trans(([{g},{h}]) => 'foo'); +>trans(([{g},{h}]) => 'foo') : number +>trans : (f: (x: T) => string) => number +>([{g},{h}]) => 'foo' : ([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string +>g : any +>h : any +>'foo' : "foo" + +trans(({a, b = 10}) => a); +>trans(({a, b = 10}) => a) : number +>trans : (f: (x: T) => string) => number +>({a, b = 10}) => a : ({ a, b }: { a: any; b?: number | undefined; }) => any +>a : any +>b : number +>10 : 10 +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..9a04ca00910e5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt @@ -0,0 +1,45 @@ +fallbackToBindingPatternForTypeInference.ts(2,7): error TS2345: Argument of type '({ a }: { a: any; }) => any' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ a: any; }'. +fallbackToBindingPatternForTypeInference.ts(3,7): error TS2345: Argument of type '([b, c]: [any, any]) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '[any, any]'. +fallbackToBindingPatternForTypeInference.ts(4,7): error TS2345: Argument of type '({ d: [e, f] }: { d: [any, any]; }) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ d: [any, any]; }'. +fallbackToBindingPatternForTypeInference.ts(5,7): error TS2345: Argument of type '([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '[{ g: any; }, { h: any; }]'. +fallbackToBindingPatternForTypeInference.ts(6,7): error TS2345: Argument of type '({ a, b }: { a: any; b?: number | undefined; }) => any' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ a: any; b?: number | undefined; }'. + + +==== fallbackToBindingPatternForTypeInference.ts (5 errors) ==== + declare function trans(f: (x: T) => string): number; + trans(({a}) => a); + ~~~~~~~~~~ +!!! error TS2345: Argument of type '({ a }: { a: any; }) => any' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ a: any; }'. + trans(([b,c]) => 'foo'); + ~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '([b, c]: [any, any]) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '[any, any]'. + trans(({d: [e,f]}) => 'foo'); + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '({ d: [e, f] }: { d: [any, any]; }) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ d: [any, any]; }'. + trans(([{g},{h}]) => 'foo'); + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '[{ g: any; }, { h: any; }]'. + trans(({a, b = 10}) => a); + ~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '({ a, b }: { a: any; b?: number | undefined; }) => any' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ a: any; b?: number | undefined; }'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).js new file mode 100644 index 0000000000000..60378832d9d6a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).js @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +//// [fallbackToBindingPatternForTypeInference.ts] +declare function trans(f: (x: T) => string): number; +trans(({a}) => a); +trans(([b,c]) => 'foo'); +trans(({d: [e,f]}) => 'foo'); +trans(([{g},{h}]) => 'foo'); +trans(({a, b = 10}) => a); + + +//// [fallbackToBindingPatternForTypeInference.js] +"use strict"; +trans(({ a }) => a); +trans(([b, c]) => 'foo'); +trans(({ d: [e, f] }) => 'foo'); +trans(([{ g }, { h }]) => 'foo'); +trans(({ a, b = 10 }) => a); diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..7e6456be8db3c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +=== fallbackToBindingPatternForTypeInference.ts === +declare function trans(f: (x: T) => string): number; +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>T : Symbol(T, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 23)) +>f : Symbol(f, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 26)) +>x : Symbol(x, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 30)) +>T : Symbol(T, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 23)) + +trans(({a}) => a); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 1, 8)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 1, 8)) + +trans(([b,c]) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>b : Symbol(b, Decl(fallbackToBindingPatternForTypeInference.ts, 2, 8)) +>c : Symbol(c, Decl(fallbackToBindingPatternForTypeInference.ts, 2, 10)) + +trans(({d: [e,f]}) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>e : Symbol(e, Decl(fallbackToBindingPatternForTypeInference.ts, 3, 12)) +>f : Symbol(f, Decl(fallbackToBindingPatternForTypeInference.ts, 3, 14)) + +trans(([{g},{h}]) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>g : Symbol(g, Decl(fallbackToBindingPatternForTypeInference.ts, 4, 9)) +>h : Symbol(h, Decl(fallbackToBindingPatternForTypeInference.ts, 4, 13)) + +trans(({a, b = 10}) => a); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 8)) +>b : Symbol(b, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 10)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 8)) + diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).types new file mode 100644 index 0000000000000..be3950ad98131 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).types @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +=== fallbackToBindingPatternForTypeInference.ts === +declare function trans(f: (x: T) => string): number; +>trans : (f: (x: T) => string) => number +>f : (x: T) => string +>x : T + +trans(({a}) => a); +>trans(({a}) => a) : number +>trans : (f: (x: T) => string) => number +>({a}) => a : ({ a }: { a: any; }) => any +>a : any +>a : any + +trans(([b,c]) => 'foo'); +>trans(([b,c]) => 'foo') : number +>trans : (f: (x: T) => string) => number +>([b,c]) => 'foo' : ([b, c]: [any, any]) => string +>b : any +>c : any +>'foo' : "foo" + +trans(({d: [e,f]}) => 'foo'); +>trans(({d: [e,f]}) => 'foo') : number +>trans : (f: (x: T) => string) => number +>({d: [e,f]}) => 'foo' : ({ d: [e, f] }: { d: [any, any]; }) => string +>d : any +>e : any +>f : any +>'foo' : "foo" + +trans(([{g},{h}]) => 'foo'); +>trans(([{g},{h}]) => 'foo') : number +>trans : (f: (x: T) => string) => number +>([{g},{h}]) => 'foo' : ([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string +>g : any +>h : any +>'foo' : "foo" + +trans(({a, b = 10}) => a); +>trans(({a, b = 10}) => a) : number +>trans : (f: (x: T) => string) => number +>({a, b = 10}) => a : ({ a, b }: { a: any; b?: number | undefined; }) => any +>a : any +>b : number +>10 : 10 +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).errors.txt new file mode 100644 index 0000000000000..29a93731f366b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).errors.txt @@ -0,0 +1,29 @@ +fixingTypeParametersRepeatedly2.ts(11,32): error TS2741: Property 'toBase' is missing in type 'Base' but required in type 'Derived'. +fixingTypeParametersRepeatedly2.ts(17,5): error TS2403: Subsequent variable declarations must have the same type. Variable 'result' must be of type 'Derived', but here has type 'Base'. + + +==== fixingTypeParametersRepeatedly2.ts (2 errors) ==== + interface Base { + baseProp; + } + interface Derived extends Base { + toBase(): Base; + } + + declare var derived: Derived; + + declare function foo(x: T, func: (p: T) => T): T; + var result = foo(derived, d => d.toBase()); + ~~~~~~~~~~ +!!! error TS2741: Property 'toBase' is missing in type 'Base' but required in type 'Derived'. +!!! related TS2728 fixingTypeParametersRepeatedly2.ts:5:5: 'toBase' is declared here. +!!! related TS6502 fixingTypeParametersRepeatedly2.ts:10:37: The expected type comes from the return type of this signature. + + // bar should type check just like foo. + // The same error should be observed in both cases. + declare function bar(x: T, func: (p: T) => T): T; + declare function bar(x: T, func: (p: T) => T): T; + var result = bar(derived, d => d.toBase()); + ~~~~~~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'result' must be of type 'Derived', but here has type 'Base'. +!!! related TS6203 fixingTypeParametersRepeatedly2.ts:11:5: 'result' was also declared here. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).js new file mode 100644 index 0000000000000..f3ab2ec0b70b2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).js @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/fixingTypeParametersRepeatedly2.ts] //// + +//// [fixingTypeParametersRepeatedly2.ts] +interface Base { + baseProp; +} +interface Derived extends Base { + toBase(): Base; +} + +declare var derived: Derived; + +declare function foo(x: T, func: (p: T) => T): T; +var result = foo(derived, d => d.toBase()); + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +declare function bar(x: T, func: (p: T) => T): T; +var result = bar(derived, d => d.toBase()); + +//// [fixingTypeParametersRepeatedly2.js] +"use strict"; +var result = foo(derived, d => d.toBase()); +var result = bar(derived, d => d.toBase()); diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).symbols new file mode 100644 index 0000000000000..7dc3504e7d3da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).symbols @@ -0,0 +1,75 @@ +//// [tests/cases/compiler/fixingTypeParametersRepeatedly2.ts] //// + +=== fixingTypeParametersRepeatedly2.ts === +interface Base { +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly2.ts, 0, 0)) + + baseProp; +>baseProp : Symbol(Base.baseProp, Decl(fixingTypeParametersRepeatedly2.ts, 0, 16)) +} +interface Derived extends Base { +>Derived : Symbol(Derived, Decl(fixingTypeParametersRepeatedly2.ts, 2, 1)) +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly2.ts, 0, 0)) + + toBase(): Base; +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly2.ts, 0, 0)) +} + +declare var derived: Derived; +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly2.ts, 7, 11)) +>Derived : Symbol(Derived, Decl(fixingTypeParametersRepeatedly2.ts, 2, 1)) + +declare function foo(x: T, func: (p: T) => T): T; +>foo : Symbol(foo, Decl(fixingTypeParametersRepeatedly2.ts, 7, 29)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly2.ts, 9, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly2.ts, 9, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly2.ts, 9, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) + +var result = foo(derived, d => d.toBase()); +>result : Symbol(result, Decl(fixingTypeParametersRepeatedly2.ts, 10, 3), Decl(fixingTypeParametersRepeatedly2.ts, 16, 3)) +>foo : Symbol(foo, Decl(fixingTypeParametersRepeatedly2.ts, 7, 29)) +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly2.ts, 7, 11)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 10, 25)) +>d.toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 10, 25)) +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly2.ts, 10, 43), Decl(fixingTypeParametersRepeatedly2.ts, 14, 52)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly2.ts, 14, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly2.ts, 14, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly2.ts, 14, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) + +declare function bar(x: T, func: (p: T) => T): T; +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly2.ts, 10, 43), Decl(fixingTypeParametersRepeatedly2.ts, 14, 52)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly2.ts, 15, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly2.ts, 15, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly2.ts, 15, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) + +var result = bar(derived, d => d.toBase()); +>result : Symbol(result, Decl(fixingTypeParametersRepeatedly2.ts, 10, 3), Decl(fixingTypeParametersRepeatedly2.ts, 16, 3)) +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly2.ts, 10, 43), Decl(fixingTypeParametersRepeatedly2.ts, 14, 52)) +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly2.ts, 7, 11)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 16, 25)) +>d.toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 16, 25)) +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) + diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).types new file mode 100644 index 0000000000000..0a8fca14e9475 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).types @@ -0,0 +1,59 @@ +//// [tests/cases/compiler/fixingTypeParametersRepeatedly2.ts] //// + +=== fixingTypeParametersRepeatedly2.ts === +interface Base { + baseProp; +>baseProp : any +} +interface Derived extends Base { + toBase(): Base; +>toBase : () => Base +} + +declare var derived: Derived; +>derived : Derived + +declare function foo(x: T, func: (p: T) => T): T; +>foo : (x: T, func: (p: T) => T) => T +>x : T +>func : (p: T) => T +>p : T + +var result = foo(derived, d => d.toBase()); +>result : Derived +>foo(derived, d => d.toBase()) : Derived +>foo : (x: T, func: (p: T) => T) => T +>derived : Derived +>d => d.toBase() : (d: Derived) => Base +>d : Derived +>d.toBase() : Base +>d.toBase : () => Base +>d : Derived +>toBase : () => Base + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +>bar : { (x: T, func: (p: T) => T): T; (x: T_1, func: (p: T_1) => T_1): T_1; } +>x : T +>func : (p: T) => T +>p : T + +declare function bar(x: T, func: (p: T) => T): T; +>bar : { (x: T_1, func: (p: T_1) => T_1): T_1; (x: T, func: (p: T) => T): T; } +>x : T +>func : (p: T) => T +>p : T + +var result = bar(derived, d => d.toBase()); +>result : Derived +>bar(derived, d => d.toBase()) : Base +>bar : { (x: T, func: (p: T) => T): T; (x: T, func: (p: T) => T): T; } +>derived : Derived +>d => d.toBase() : (d: Derived) => Base +>d : Derived +>d.toBase() : Base +>d.toBase : () => Base +>d : Derived +>toBase : () => Base + diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..29a93731f366b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt @@ -0,0 +1,29 @@ +fixingTypeParametersRepeatedly2.ts(11,32): error TS2741: Property 'toBase' is missing in type 'Base' but required in type 'Derived'. +fixingTypeParametersRepeatedly2.ts(17,5): error TS2403: Subsequent variable declarations must have the same type. Variable 'result' must be of type 'Derived', but here has type 'Base'. + + +==== fixingTypeParametersRepeatedly2.ts (2 errors) ==== + interface Base { + baseProp; + } + interface Derived extends Base { + toBase(): Base; + } + + declare var derived: Derived; + + declare function foo(x: T, func: (p: T) => T): T; + var result = foo(derived, d => d.toBase()); + ~~~~~~~~~~ +!!! error TS2741: Property 'toBase' is missing in type 'Base' but required in type 'Derived'. +!!! related TS2728 fixingTypeParametersRepeatedly2.ts:5:5: 'toBase' is declared here. +!!! related TS6502 fixingTypeParametersRepeatedly2.ts:10:37: The expected type comes from the return type of this signature. + + // bar should type check just like foo. + // The same error should be observed in both cases. + declare function bar(x: T, func: (p: T) => T): T; + declare function bar(x: T, func: (p: T) => T): T; + var result = bar(derived, d => d.toBase()); + ~~~~~~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'result' must be of type 'Derived', but here has type 'Base'. +!!! related TS6203 fixingTypeParametersRepeatedly2.ts:11:5: 'result' was also declared here. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).js new file mode 100644 index 0000000000000..f3ab2ec0b70b2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).js @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/fixingTypeParametersRepeatedly2.ts] //// + +//// [fixingTypeParametersRepeatedly2.ts] +interface Base { + baseProp; +} +interface Derived extends Base { + toBase(): Base; +} + +declare var derived: Derived; + +declare function foo(x: T, func: (p: T) => T): T; +var result = foo(derived, d => d.toBase()); + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +declare function bar(x: T, func: (p: T) => T): T; +var result = bar(derived, d => d.toBase()); + +//// [fixingTypeParametersRepeatedly2.js] +"use strict"; +var result = foo(derived, d => d.toBase()); +var result = bar(derived, d => d.toBase()); diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..7dc3504e7d3da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).symbols @@ -0,0 +1,75 @@ +//// [tests/cases/compiler/fixingTypeParametersRepeatedly2.ts] //// + +=== fixingTypeParametersRepeatedly2.ts === +interface Base { +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly2.ts, 0, 0)) + + baseProp; +>baseProp : Symbol(Base.baseProp, Decl(fixingTypeParametersRepeatedly2.ts, 0, 16)) +} +interface Derived extends Base { +>Derived : Symbol(Derived, Decl(fixingTypeParametersRepeatedly2.ts, 2, 1)) +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly2.ts, 0, 0)) + + toBase(): Base; +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly2.ts, 0, 0)) +} + +declare var derived: Derived; +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly2.ts, 7, 11)) +>Derived : Symbol(Derived, Decl(fixingTypeParametersRepeatedly2.ts, 2, 1)) + +declare function foo(x: T, func: (p: T) => T): T; +>foo : Symbol(foo, Decl(fixingTypeParametersRepeatedly2.ts, 7, 29)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly2.ts, 9, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly2.ts, 9, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly2.ts, 9, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 9, 21)) + +var result = foo(derived, d => d.toBase()); +>result : Symbol(result, Decl(fixingTypeParametersRepeatedly2.ts, 10, 3), Decl(fixingTypeParametersRepeatedly2.ts, 16, 3)) +>foo : Symbol(foo, Decl(fixingTypeParametersRepeatedly2.ts, 7, 29)) +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly2.ts, 7, 11)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 10, 25)) +>d.toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 10, 25)) +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly2.ts, 10, 43), Decl(fixingTypeParametersRepeatedly2.ts, 14, 52)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly2.ts, 14, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly2.ts, 14, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly2.ts, 14, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 14, 21)) + +declare function bar(x: T, func: (p: T) => T): T; +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly2.ts, 10, 43), Decl(fixingTypeParametersRepeatedly2.ts, 14, 52)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly2.ts, 15, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly2.ts, 15, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly2.ts, 15, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly2.ts, 15, 21)) + +var result = bar(derived, d => d.toBase()); +>result : Symbol(result, Decl(fixingTypeParametersRepeatedly2.ts, 10, 3), Decl(fixingTypeParametersRepeatedly2.ts, 16, 3)) +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly2.ts, 10, 43), Decl(fixingTypeParametersRepeatedly2.ts, 14, 52)) +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly2.ts, 7, 11)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 16, 25)) +>d.toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly2.ts, 16, 25)) +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly2.ts, 3, 32)) + diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).types new file mode 100644 index 0000000000000..0a8fca14e9475 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).types @@ -0,0 +1,59 @@ +//// [tests/cases/compiler/fixingTypeParametersRepeatedly2.ts] //// + +=== fixingTypeParametersRepeatedly2.ts === +interface Base { + baseProp; +>baseProp : any +} +interface Derived extends Base { + toBase(): Base; +>toBase : () => Base +} + +declare var derived: Derived; +>derived : Derived + +declare function foo(x: T, func: (p: T) => T): T; +>foo : (x: T, func: (p: T) => T) => T +>x : T +>func : (p: T) => T +>p : T + +var result = foo(derived, d => d.toBase()); +>result : Derived +>foo(derived, d => d.toBase()) : Derived +>foo : (x: T, func: (p: T) => T) => T +>derived : Derived +>d => d.toBase() : (d: Derived) => Base +>d : Derived +>d.toBase() : Base +>d.toBase : () => Base +>d : Derived +>toBase : () => Base + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +>bar : { (x: T, func: (p: T) => T): T; (x: T_1, func: (p: T_1) => T_1): T_1; } +>x : T +>func : (p: T) => T +>p : T + +declare function bar(x: T, func: (p: T) => T): T; +>bar : { (x: T_1, func: (p: T_1) => T_1): T_1; (x: T, func: (p: T) => T): T; } +>x : T +>func : (p: T) => T +>p : T + +var result = bar(derived, d => d.toBase()); +>result : Derived +>bar(derived, d => d.toBase()) : Base +>bar : { (x: T, func: (p: T) => T): T; (x: T, func: (p: T) => T): T; } +>derived : Derived +>d => d.toBase() : (d: Derived) => Base +>d : Derived +>d.toBase() : Base +>d.toBase : () => Base +>d : Derived +>toBase : () => Base + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..6e19f55994980 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).symbols @@ -0,0 +1,3060 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +let x: string | number = 0; +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) +} +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +const deep = x; +>deep : Symbol(deep, Decl(flowLoopDepthCheckOrder.ts, 1023, 5)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..efbb9a68a52ad --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).types @@ -0,0 +1,3069 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : () => boolean + +declare let b: boolean; +>b : boolean + +let x: string | number = 0; +>x : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>typeof x === "string" : boolean +>typeof x : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>x : string | number +>"string" : "string" +>x = 1 : 1 +>x : string | number +>1 : 1 +>x = "a" : "a" +>x : string | number +>"a" : "a" + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean +} +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +const deep = x; +>deep : string | number +>x : string | number + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..6e19f55994980 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,3060 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +let x: string | number = 0; +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) +} +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +const deep = x; +>deep : Symbol(deep, Decl(flowLoopDepthCheckOrder.ts, 1023, 5)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..efbb9a68a52ad --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,3069 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : () => boolean + +declare let b: boolean; +>b : boolean + +let x: string | number = 0; +>x : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>typeof x === "string" : boolean +>typeof x : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>x : string | number +>"string" : "string" +>x = 1 : 1 +>x : string | number +>1 : 1 +>x = "a" : "a" +>x : string | number +>"a" : "a" + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean +} +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +const deep = x; +>deep : string | number +>x : string | number + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..b43190520aaab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,1126 @@ +flowLoopTooDeepCheckOrder.ts(4,1): error TS2563: The containing function or module body is too large for control flow analysis. + + +==== flowLoopTooDeepCheckOrder.ts (1 errors) ==== + // The loop is too deep to analyze from any reference, so 'narrowed' gives + // up whether or not the reference in the loop analyzed the loop first. + + declare function cond(): boolean; + ~~~~~~~ +!!! error TS2563: The containing function or module body is too large for control flow analysis. + declare function isString(value: unknown): value is string; + declare let b: boolean; + + let w: string | number = 0; + while (cond()) { + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (typeof w === "string") { w = 1; } else { w = "a"; } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + } + if (isString(w)) { + const narrowed = w; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..42c2e0915139d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).symbols @@ -0,0 +1,3352 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + +declare function isString(value: unknown): value is string; +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + +let w: string | number = 0; +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) +} +if (isString(w)) { +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + const narrowed = w; +>narrowed : Symbol(narrowed, Decl(flowLoopTooDeepCheckOrder.ts, 1117, 9)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..1aa8a74fe18dd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types @@ -0,0 +1,3361 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : () => boolean + +declare function isString(value: unknown): value is string; +>isString : (value: unknown) => value is string +>value : unknown + +declare let b: boolean; +>b : boolean + +let w: string | number = 0; +>w : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>typeof w === "string" : boolean +>typeof w : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>w : any +>"string" : "string" +>w = 1 : 1 +>w : string | number +>1 : 1 +>w = "a" : "a" +>w : string | number +>"a" : "a" + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any +} +if (isString(w)) { +>isString(w) : boolean +>isString : (value: unknown) => value is string +>w : any + + const narrowed = w; +>narrowed : any +>w : any +} + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..b43190520aaab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,1126 @@ +flowLoopTooDeepCheckOrder.ts(4,1): error TS2563: The containing function or module body is too large for control flow analysis. + + +==== flowLoopTooDeepCheckOrder.ts (1 errors) ==== + // The loop is too deep to analyze from any reference, so 'narrowed' gives + // up whether or not the reference in the loop analyzed the loop first. + + declare function cond(): boolean; + ~~~~~~~ +!!! error TS2563: The containing function or module body is too large for control flow analysis. + declare function isString(value: unknown): value is string; + declare let b: boolean; + + let w: string | number = 0; + while (cond()) { + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (typeof w === "string") { w = 1; } else { w = "a"; } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + } + if (isString(w)) { + const narrowed = w; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..42c2e0915139d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,3352 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + +declare function isString(value: unknown): value is string; +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + +let w: string | number = 0; +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) +} +if (isString(w)) { +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + const narrowed = w; +>narrowed : Symbol(narrowed, Decl(flowLoopTooDeepCheckOrder.ts, 1117, 9)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..1aa8a74fe18dd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,3361 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : () => boolean + +declare function isString(value: unknown): value is string; +>isString : (value: unknown) => value is string +>value : unknown + +declare let b: boolean; +>b : boolean + +let w: string | number = 0; +>w : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>typeof w === "string" : boolean +>typeof w : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>w : any +>"string" : "string" +>w = 1 : 1 +>w : string | number +>1 : 1 +>w = "a" : "a" +>w : string | number +>"a" : "a" + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any +} +if (isString(w)) { +>isString(w) : boolean +>isString : (value: unknown) => value is string +>w : any + + const narrowed = w; +>narrowed : any +>w : any +} + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallInferenceUsingThisTypeNoInvalidCacheReuseAfterMappedTypeApplication1.types b/tsc/testdata/baselines/reference/compiler/genericCallInferenceUsingThisTypeNoInvalidCacheReuseAfterMappedTypeApplication1.types index c6a517dc1a0c3..63ccf34626aea 100644 --- a/tsc/testdata/baselines/reference/compiler/genericCallInferenceUsingThisTypeNoInvalidCacheReuseAfterMappedTypeApplication1.types +++ b/tsc/testdata/baselines/reference/compiler/genericCallInferenceUsingThisTypeNoInvalidCacheReuseAfterMappedTypeApplication1.types @@ -92,10 +92,10 @@ export const a = inner.log(100); // Effect<100, never, never> >100 : 100 export const b = outer.log(100); // Effect<100, never, XXX> ->b : Effect<100, never, never> ->outer.log(100) : Effect<100, never, never> ->outer.log : (n: N) => Effect +>b : Effect<100, never, XXX> +>outer.log(100) : Effect<100, never, XXX> +>outer.log : (n: N) => Effect >outer : ProxyMap ->log : (n: N) => Effect +>log : (n: N) => Effect >100 : 100 diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).errors.txt new file mode 100644 index 0000000000000..adfc91cadd7fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).errors.txt @@ -0,0 +1,31 @@ +genericCallReturnedFunctionParameterDefault.ts(24,5): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== genericCallReturnedFunctionParameterDefault.ts (1 errors) ==== + // The function returned from the callback of a generic call has a parameter + // with a default and no annotation. Once T is inferred, the contextual + // signature of the returned function is its own signature, but the parameter + // already has its type (boolean) from the initializer, computed while T was + // being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an + // error. (Reduced from open-design ProjectView.tsx, useCallback returning + // '{ release: (recoverable = false) => ... }'.) + + declare function id(callback: T): T; + + id(() => { + return (x = false) => {}; + }); + + id(() => (y = false) => y); + + id(() => { + return { m(z = false) {} }; + }); + + const r = id(() => { + return (w = 0) => {}; + }); + r()(""); + ~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).symbols new file mode 100644 index 0000000000000..ee8aa11e466f0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>callback : Symbol(callback, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 23)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (x = false) => {}; +>x : Symbol(x, Decl(genericCallReturnedFunctionParameterDefault.ts, 11, 12)) + +}); + +id(() => (y = false) => y); +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return { m(z = false) {} }; +>m : Symbol(m, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 12)) +>z : Symbol(z, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 15)) + +}); + +const r = id(() => { +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (w = 0) => {}; +>w : Symbol(w, Decl(genericCallReturnedFunctionParameterDefault.ts, 21, 12)) + +}); +r()(""); +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).types new file mode 100644 index 0000000000000..a8c98c3242e89 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).types @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : (callback: T) => T +>callback : T + +id(() => { +>id(() => { return (x = false) => {};}) : () => (x?: boolean) => void +>id : (callback: T) => T +>() => { return (x = false) => {};} : () => (x?: boolean) => void + + return (x = false) => {}; +>(x = false) => {} : (x?: boolean) => void +>x : boolean +>false : false + +}); + +id(() => (y = false) => y); +>id(() => (y = false) => y) : () => (y?: boolean) => boolean +>id : (callback: T) => T +>() => (y = false) => y : () => (y?: boolean) => boolean +>(y = false) => y : (y?: boolean) => boolean +>y : boolean +>false : false +>y : boolean + +id(() => { +>id(() => { return { m(z = false) {} };}) : () => { m(z?: boolean): void; } +>id : (callback: T) => T +>() => { return { m(z = false) {} };} : () => { m(z?: boolean): void; } + + return { m(z = false) {} }; +>{ m(z = false) {} } : { m(z?: boolean): void; } +>m : (z?: boolean) => void +>z : boolean +>false : false + +}); + +const r = id(() => { +>r : () => (w?: number) => void +>id(() => { return (w = 0) => {};}) : () => (w?: number) => void +>id : (callback: T) => T +>() => { return (w = 0) => {};} : () => (w?: number) => void + + return (w = 0) => {}; +>(w = 0) => {} : (w?: number) => void +>w : number +>0 : 0 + +}); +r()(""); +>r()("") : void +>r() : (w?: number) => void +>r : () => (w?: number) => void +>"" : "" + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..adfc91cadd7fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).errors.txt @@ -0,0 +1,31 @@ +genericCallReturnedFunctionParameterDefault.ts(24,5): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== genericCallReturnedFunctionParameterDefault.ts (1 errors) ==== + // The function returned from the callback of a generic call has a parameter + // with a default and no annotation. Once T is inferred, the contextual + // signature of the returned function is its own signature, but the parameter + // already has its type (boolean) from the initializer, computed while T was + // being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an + // error. (Reduced from open-design ProjectView.tsx, useCallback returning + // '{ release: (recoverable = false) => ... }'.) + + declare function id(callback: T): T; + + id(() => { + return (x = false) => {}; + }); + + id(() => (y = false) => y); + + id(() => { + return { m(z = false) {} }; + }); + + const r = id(() => { + return (w = 0) => {}; + }); + r()(""); + ~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..ee8aa11e466f0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>callback : Symbol(callback, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 23)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (x = false) => {}; +>x : Symbol(x, Decl(genericCallReturnedFunctionParameterDefault.ts, 11, 12)) + +}); + +id(() => (y = false) => y); +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return { m(z = false) {} }; +>m : Symbol(m, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 12)) +>z : Symbol(z, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 15)) + +}); + +const r = id(() => { +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (w = 0) => {}; +>w : Symbol(w, Decl(genericCallReturnedFunctionParameterDefault.ts, 21, 12)) + +}); +r()(""); +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).types new file mode 100644 index 0000000000000..a8c98c3242e89 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).types @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : (callback: T) => T +>callback : T + +id(() => { +>id(() => { return (x = false) => {};}) : () => (x?: boolean) => void +>id : (callback: T) => T +>() => { return (x = false) => {};} : () => (x?: boolean) => void + + return (x = false) => {}; +>(x = false) => {} : (x?: boolean) => void +>x : boolean +>false : false + +}); + +id(() => (y = false) => y); +>id(() => (y = false) => y) : () => (y?: boolean) => boolean +>id : (callback: T) => T +>() => (y = false) => y : () => (y?: boolean) => boolean +>(y = false) => y : (y?: boolean) => boolean +>y : boolean +>false : false +>y : boolean + +id(() => { +>id(() => { return { m(z = false) {} };}) : () => { m(z?: boolean): void; } +>id : (callback: T) => T +>() => { return { m(z = false) {} };} : () => { m(z?: boolean): void; } + + return { m(z = false) {} }; +>{ m(z = false) {} } : { m(z?: boolean): void; } +>m : (z?: boolean) => void +>z : boolean +>false : false + +}); + +const r = id(() => { +>r : () => (w?: number) => void +>id(() => { return (w = 0) => {};}) : () => (w?: number) => void +>id : (callback: T) => T +>() => { return (w = 0) => {};} : () => (w?: number) => void + + return (w = 0) => {}; +>(w = 0) => {} : (w?: number) => void +>w : number +>0 : 0 + +}); +r()(""); +>r()("") : void +>r() : (w?: number) => void +>r : () => (w?: number) => void +>"" : "" + diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.errors.txt b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.errors.txt new file mode 100644 index 0000000000000..ada42d0527e20 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.errors.txt @@ -0,0 +1,17 @@ +getterCircularityDiagnostics.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== getterCircularityDiagnostics.ts (1 errors) ==== + declare const props: Options; + + class Container { + get options() { + ~~~~~~~ +!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return { container: this, ...props } as Options; + } + } + + interface Options { + container?: Container; + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.js b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.js new file mode 100644 index 0000000000000..e7507ff16bec4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.js @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/getterCircularityDiagnostics.ts] //// + +//// [getterCircularityDiagnostics.ts] +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} + +//// [getterCircularityDiagnostics.js] +"use strict"; +class Container { + get options() { + return Object.assign({ container: this }, props); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.symbols b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.symbols new file mode 100644 index 0000000000000..7ef53202b8061 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.symbols @@ -0,0 +1,28 @@ +//// [tests/cases/compiler/getterCircularityDiagnostics.ts] //// + +=== getterCircularityDiagnostics.ts === +declare const props: Options; +>props : Symbol(props, Decl(getterCircularityDiagnostics.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterCircularityDiagnostics.ts, 6, 1)) + +class Container { +>Container : Symbol(Container, Decl(getterCircularityDiagnostics.ts, 0, 29)) + + get options() { +>options : Symbol(Container.options, Decl(getterCircularityDiagnostics.ts, 2, 17)) + + return { container: this, ...props } as Options; +>container : Symbol(container, Decl(getterCircularityDiagnostics.ts, 4, 16)) +>this : Symbol(Container, Decl(getterCircularityDiagnostics.ts, 0, 29)) +>props : Symbol(props, Decl(getterCircularityDiagnostics.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterCircularityDiagnostics.ts, 6, 1)) + } +} + +interface Options { +>Options : Symbol(Options, Decl(getterCircularityDiagnostics.ts, 6, 1)) + + container?: Container; +>container : Symbol(Options.container, Decl(getterCircularityDiagnostics.ts, 8, 19)) +>Container : Symbol(Container, Decl(getterCircularityDiagnostics.ts, 0, 29)) +} diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.types b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.types new file mode 100644 index 0000000000000..03f8b125b218d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.types @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/getterCircularityDiagnostics.ts] //// + +=== getterCircularityDiagnostics.ts === +declare const props: Options; +>props : Options + +class Container { +>Container : Container + + get options() { +>options : any + + return { container: this, ...props } as Options; +>{ container: this, ...props } as Options : Options +>{ container: this, ...props } : { container: Container; } +>container : this +>this : this +>props : Options + } +} + +interface Options { + container?: Container; +>container : Container | undefined +} diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..4f28621217936 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).errors.txt @@ -0,0 +1,18 @@ +getterReturnTypeQueryOrder.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== getterReturnTypeQueryOrder.ts (1 errors) ==== + declare const props: Options; + + class Container { + get options() { + ~~~~~~~ +!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return { container: this, ...props } as Options; + } + } + + interface Options { + container?: Container; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..86ae054a9e244 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).js @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +//// [getterReturnTypeQueryOrder.ts] +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} + + +//// [getterReturnTypeQueryOrder.js] +"use strict"; +class Container { + get options() { + return Object.assign({ container: this }, props); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..0425451cdc246 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + +class Container { +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) + + get options() { +>options : Symbol(Container.options, Decl(getterReturnTypeQueryOrder.ts, 2, 17)) + + return { container: this, ...props } as Options; +>container : Symbol(container, Decl(getterReturnTypeQueryOrder.ts, 4, 16)) +>this : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + } +} + +interface Options { +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + + container?: Container; +>container : Symbol(Options.container, Decl(getterReturnTypeQueryOrder.ts, 8, 19)) +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..df84cc21241ea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Options + +class Container { +>Container : Container + + get options() { +>options : any + + return { container: this, ...props } as Options; +>{ container: this, ...props } as Options : Options +>{ container: this, ...props } : { container: Container; } +>container : this +>this : this +>props : Options + } +} + +interface Options { + container?: Container; +>container : Container | undefined +} + diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..4f28621217936 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,18 @@ +getterReturnTypeQueryOrder.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== getterReturnTypeQueryOrder.ts (1 errors) ==== + declare const props: Options; + + class Container { + get options() { + ~~~~~~~ +!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return { container: this, ...props } as Options; + } + } + + interface Options { + container?: Container; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..86ae054a9e244 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +//// [getterReturnTypeQueryOrder.ts] +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} + + +//// [getterReturnTypeQueryOrder.js] +"use strict"; +class Container { + get options() { + return Object.assign({ container: this }, props); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..0425451cdc246 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + +class Container { +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) + + get options() { +>options : Symbol(Container.options, Decl(getterReturnTypeQueryOrder.ts, 2, 17)) + + return { container: this, ...props } as Options; +>container : Symbol(container, Decl(getterReturnTypeQueryOrder.ts, 4, 16)) +>this : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + } +} + +interface Options { +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + + container?: Container; +>container : Symbol(Options.container, Decl(getterReturnTypeQueryOrder.ts, 8, 19)) +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..df84cc21241ea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Options + +class Container { +>Container : Container + + get options() { +>options : any + + return { container: this, ...props } as Options; +>{ container: this, ...props } as Options : Options +>{ container: this, ...props } : { container: Container; } +>container : this +>this : this +>props : Options + } +} + +interface Options { + container?: Container; +>container : Container | undefined +} + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..ebb125845b45c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,22 @@ +importAttributeValueCheckOrder.ts(5,15): error TS2307: Cannot find module 'x' or its corresponding type declarations. +importAttributeValueCheckOrder.ts(5,19): error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. + Property 'a' is incompatible with index signature. + Type 'number' is not assignable to type 'string'. +importAttributeValueCheckOrder.ts(5,29): error TS2858: Import attribute values must be string literal expressions. + + +==== importAttributeValueCheckOrder.ts (3 errors) ==== + // The attribute value is invalid, which does not affect the module. Its + // missing module must be reported whether or not the type of x is queried + // before the import is checked. + + import x from "x" with { a: 0 }; + ~~~ +!!! error TS2307: Cannot find module 'x' or its corresponding type declarations. + ~~~~~~~~~~~~~ +!!! error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. +!!! error TS2322: Property 'a' is incompatible with index signature. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~ +!!! error TS2858: Import attribute values must be string literal expressions. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..97e58214a9ea0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).js @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +//// [importAttributeValueCheckOrder.ts] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; + + +//// [importAttributeValueCheckOrder.js] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3af978ee9fe99 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).symbols @@ -0,0 +1,10 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : Symbol(x, Decl(importAttributeValueCheckOrder.ts, 4, 6)) + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..d0a03be7dfcaf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).types @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : any +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..ebb125845b45c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,22 @@ +importAttributeValueCheckOrder.ts(5,15): error TS2307: Cannot find module 'x' or its corresponding type declarations. +importAttributeValueCheckOrder.ts(5,19): error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. + Property 'a' is incompatible with index signature. + Type 'number' is not assignable to type 'string'. +importAttributeValueCheckOrder.ts(5,29): error TS2858: Import attribute values must be string literal expressions. + + +==== importAttributeValueCheckOrder.ts (3 errors) ==== + // The attribute value is invalid, which does not affect the module. Its + // missing module must be reported whether or not the type of x is queried + // before the import is checked. + + import x from "x" with { a: 0 }; + ~~~ +!!! error TS2307: Cannot find module 'x' or its corresponding type declarations. + ~~~~~~~~~~~~~ +!!! error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. +!!! error TS2322: Property 'a' is incompatible with index signature. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~ +!!! error TS2858: Import attribute values must be string literal expressions. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..97e58214a9ea0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +//// [importAttributeValueCheckOrder.ts] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; + + +//// [importAttributeValueCheckOrder.js] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3af978ee9fe99 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,10 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : Symbol(x, Decl(importAttributeValueCheckOrder.ts, 4, 6)) + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..d0a03be7dfcaf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : any +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt b/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt index 12e30795fff58..ddfbafc65341d 100644 --- a/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt @@ -1,15 +1,12 @@ importDeclWithClassModifiers.ts(5,8): error TS1044: 'public' modifier cannot appear on a module or namespace element. -importDeclWithClassModifiers.ts(5,26): error TS2708: Cannot use namespace 'x' as a value. importDeclWithClassModifiers.ts(5,28): error TS2694: Namespace 'x' has no exported member 'c'. importDeclWithClassModifiers.ts(6,8): error TS1044: 'private' modifier cannot appear on a module or namespace element. -importDeclWithClassModifiers.ts(6,27): error TS2708: Cannot use namespace 'x' as a value. importDeclWithClassModifiers.ts(6,29): error TS2694: Namespace 'x' has no exported member 'c'. importDeclWithClassModifiers.ts(7,8): error TS1044: 'static' modifier cannot appear on a module or namespace element. -importDeclWithClassModifiers.ts(7,26): error TS2708: Cannot use namespace 'x' as a value. importDeclWithClassModifiers.ts(7,28): error TS2694: Namespace 'x' has no exported member 'c'. -==== importDeclWithClassModifiers.ts (9 errors) ==== +==== importDeclWithClassModifiers.ts (6 errors) ==== namespace x { interface c { } @@ -17,22 +14,16 @@ importDeclWithClassModifiers.ts(7,28): error TS2694: Namespace 'x' has no export export public import a = x.c; ~~~~~~ !!! error TS1044: 'public' modifier cannot appear on a module or namespace element. - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export private import b = x.c; ~~~~~~~ !!! error TS1044: 'private' modifier cannot appear on a module or namespace element. - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export static import c = x.c; ~~~~~~ !!! error TS1044: 'static' modifier cannot appear on a module or namespace element. - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt index 8da059494431f..282fc28e8acd5 100644 --- a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt @@ -1,15 +1,12 @@ -importDeclWithExportModifier.ts(5,19): error TS2708: Cannot use namespace 'x' as a value. importDeclWithExportModifier.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. -==== importDeclWithExportModifier.ts (2 errors) ==== +==== importDeclWithExportModifier.ts (1 errors) ==== namespace x { interface c { } } export import a = x.c; - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt index d4420d401f29a..083e112ea0c32 100644 --- a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt @@ -1,16 +1,13 @@ -importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2708: Cannot use namespace 'x' as a value. importDeclWithExportModifierAndExportAssignment.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. importDeclWithExportModifierAndExportAssignment.ts(6,1): error TS2309: An export assignment cannot be used in a module with other exported elements. -==== importDeclWithExportModifierAndExportAssignment.ts (3 errors) ==== +==== importDeclWithExportModifierAndExportAssignment.ts (2 errors) ==== namespace x { interface c { } } export import a = x.c; - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export = x; diff --git a/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt b/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt index 41f682e455f8d..4fc215b0dd52d 100644 --- a/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt @@ -8,10 +8,8 @@ incorrectRecursiveMappedTypeConstraint.ts(3,5): error TS2365: Operator '+=' cann function sum(n: number, v: T, k: K) { ~~~~~~~~~~~~~~~~~~~~ !!! error TS2313: Type parameter 'T' has a circular constraint. -!!! related TS2751 incorrectRecursiveMappedTypeConstraint.ts:3:10: Circularity originates in type at this location. ~ !!! error TS2313: Type parameter 'P' has a circular constraint. -!!! related TS2751 incorrectRecursiveMappedTypeConstraint.ts:3:10: Circularity originates in type at this location. n += v[k]; ~~~~~~~~~ !!! error TS2365: Operator '+=' cannot be applied to types 'number' and 'T[K]'. diff --git a/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.symbols b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.symbols new file mode 100644 index 0000000000000..da0c2151df68c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts] //// + +=== indexSignatureWithIndexedAccessOfDerivedInterface.ts === +// The type of data in TokenNode is assignable to its inherited index +// signature, which mentions it through an indexed access. + +interface BaseNode { +>BaseNode : Symbol(BaseNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 0, 0)) + + kind: string; +>kind : Symbol(BaseNode.kind, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 3, 20)) + + [key: string]: string | TokenNode["data"]; +>key : Symbol(key, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 5, 3)) +>TokenNode : Symbol(TokenNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 6, 1)) +} + +interface TokenNode extends BaseNode { +>TokenNode : Symbol(TokenNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 6, 1)) +>BaseNode : Symbol(BaseNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 0, 0)) + + kind: 'token'; +>kind : Symbol(TokenNode.kind, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 8, 38)) + + data: TokenData; +>data : Symbol(TokenNode.data, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 9, 16)) +>TokenData : Symbol(TokenData, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 11, 1)) +} + +interface TokenData { +>TokenData : Symbol(TokenData, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 11, 1)) + + offset: number; +>offset : Symbol(TokenData.offset, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 13, 21)) + + width: number; +>width : Symbol(TokenData.width, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 14, 17)) + + leading_width: number; +>leading_width : Symbol(TokenData.leading_width, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 15, 16)) + + trailing_width: number; +>trailing_width : Symbol(TokenData.trailing_width, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 16, 24)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.types b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.types new file mode 100644 index 0000000000000..8dfc18dcb19e8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.types @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts] //// + +=== indexSignatureWithIndexedAccessOfDerivedInterface.ts === +// The type of data in TokenNode is assignable to its inherited index +// signature, which mentions it through an indexed access. + +interface BaseNode { + kind: string; +>kind : string + + [key: string]: string | TokenNode["data"]; +>key : string +} + +interface TokenNode extends BaseNode { + kind: 'token'; +>kind : "token" + + data: TokenData; +>data : TokenData +} + +interface TokenData { + offset: number; +>offset : number + + width: number; +>width : number + + leading_width: number; +>leading_width : number + + trailing_width: number; +>trailing_width : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..1c03287916ff1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).symbols @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts] //// + +=== indexedAccessAccessFlagsUnionOrder.ts === +function f, K extends keyof T>(obj: T, k: K, b: boolean) { +>f : Symbol(f, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 0)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) + + const x = b ? obj[k] : g(); +>x : Symbol(x, Decl(indexedAccessAccessFlagsUnionOrder.ts, 1, 9)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) + + const s1: string = x; +>s1 : Symbol(s1, Decl(indexedAccessAccessFlagsUnionOrder.ts, 2, 9)) +>x : Symbol(x, Decl(indexedAccessAccessFlagsUnionOrder.ts, 1, 9)) + + const y = b ? g() : obj[k]; +>y : Symbol(y, Decl(indexedAccessAccessFlagsUnionOrder.ts, 3, 9)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) + + const s2: string = y; +>s2 : Symbol(s2, Decl(indexedAccessAccessFlagsUnionOrder.ts, 4, 9)) +>y : Symbol(y, Decl(indexedAccessAccessFlagsUnionOrder.ts, 3, 9)) +} + +declare function g(): T[K]; +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 21)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 21)) + diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types new file mode 100644 index 0000000000000..3842ea2cb6352 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts] //// + +=== indexedAccessAccessFlagsUnionOrder.ts === +function f, K extends keyof T>(obj: T, k: K, b: boolean) { +>f : , K extends keyof T>(obj: T, k: K, b: boolean) => void +>obj : T +>k : K +>b : boolean + + const x = b ? obj[k] : g(); +>x : T[K] +>b ? obj[k] : g() : T[K] +>b : boolean +>obj[k] : T[K] +>obj : T +>k : K +>g() : T[K] +>g : () => T_1[K_1] + + const s1: string = x; +>s1 : string +>x : T[K] + + const y = b ? g() : obj[k]; +>y : T[K] +>b ? g() : obj[k] : T[K] +>b : boolean +>g() : T[K] +>g : () => T_1[K_1] +>obj[k] : T[K] +>obj : T +>k : K + + const s2: string = y; +>s2 : string +>y : T[K] +} + +declare function g(): T[K]; +>g : () => T[K] + diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..1c03287916ff1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).symbols @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts] //// + +=== indexedAccessAccessFlagsUnionOrder.ts === +function f, K extends keyof T>(obj: T, k: K, b: boolean) { +>f : Symbol(f, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 0)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) + + const x = b ? obj[k] : g(); +>x : Symbol(x, Decl(indexedAccessAccessFlagsUnionOrder.ts, 1, 9)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) + + const s1: string = x; +>s1 : Symbol(s1, Decl(indexedAccessAccessFlagsUnionOrder.ts, 2, 9)) +>x : Symbol(x, Decl(indexedAccessAccessFlagsUnionOrder.ts, 1, 9)) + + const y = b ? g() : obj[k]; +>y : Symbol(y, Decl(indexedAccessAccessFlagsUnionOrder.ts, 3, 9)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) + + const s2: string = y; +>s2 : Symbol(s2, Decl(indexedAccessAccessFlagsUnionOrder.ts, 4, 9)) +>y : Symbol(y, Decl(indexedAccessAccessFlagsUnionOrder.ts, 3, 9)) +} + +declare function g(): T[K]; +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 21)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 21)) + diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..3842ea2cb6352 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts] //// + +=== indexedAccessAccessFlagsUnionOrder.ts === +function f, K extends keyof T>(obj: T, k: K, b: boolean) { +>f : , K extends keyof T>(obj: T, k: K, b: boolean) => void +>obj : T +>k : K +>b : boolean + + const x = b ? obj[k] : g(); +>x : T[K] +>b ? obj[k] : g() : T[K] +>b : boolean +>obj[k] : T[K] +>obj : T +>k : K +>g() : T[K] +>g : () => T_1[K_1] + + const s1: string = x; +>s1 : string +>x : T[K] + + const y = b ? g() : obj[k]; +>y : T[K] +>b ? g() : obj[k] : T[K] +>b : boolean +>g() : T[K] +>g : () => T_1[K_1] +>obj[k] : T[K] +>obj : T +>k : K + + const s2: string = y; +>s2 : string +>y : T[K] +} + +declare function g(): T[K]; +>g : () => T[K] + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..1267ee1cbc4a6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).js @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +type S = Copy<{ x: 0 } & T>; +type I = {} extends S ? U : never; + + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.js] +"use strict"; +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..20615918e8733 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) + +type S = Copy<{ x: 0 } & T>; +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>x : Symbol(x, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 33)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) + +type I = {} extends S ? U : never; +>I : Symbol(I, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 46)) +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..f7d45d2ef1677 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Copy + +type S = Copy<{ x: 0 } & T>; +>S : Copy<{ x: 0; } & T> +>x : 0 + +type I = {} extends S ? U : never; +>I : never + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..1267ee1cbc4a6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +type S = Copy<{ x: 0 } & T>; +type I = {} extends S ? U : never; + + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.js] +"use strict"; +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..20615918e8733 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) + +type S = Copy<{ x: 0 } & T>; +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>x : Symbol(x, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 33)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) + +type I = {} extends S ? U : never; +>I : Symbol(I, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 46)) +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..f7d45d2ef1677 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Copy + +type S = Copy<{ x: 0 } & T>; +>S : Copy<{ x: 0; } & T> +>x : 0 + +type I = {} extends S ? U : never; +>I : never + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt new file mode 100644 index 0000000000000..b98c3dd4a3075 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt @@ -0,0 +1,24 @@ +first.ts(3,7): error TS2322: Type 'string[]' is not assignable to type 'null'. +second.ts(6,7): error TS2322: Type 'number[]' is not assignable to type 'null'. + + +==== first.ts (1 errors) ==== + declare function flatten1(iterable: Iterable>): T[]; + declare const lists1: string[][]; + const flat1: null = flatten1(lists1); + ~~~~~ +!!! error TS2322: Type 'string[]' is not assignable to type 'null'. + + declare const items1: string[]; + for (const item of items1) {} + +==== second.ts (1 errors) ==== + declare const items2: number[]; + for (const item of items2) {} + + declare function flatten2(iterable: Iterable>): T[]; + declare const lists2: number[][]; + const flat2: null = flatten2(lists2); + ~~~~~ +!!! error TS2322: Type 'number[]' is not assignable to type 'null'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.symbols b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.symbols new file mode 100644 index 0000000000000..57cb4ce9d6984 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.symbols @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/inferenceDeeplyNestedCheckOrder.ts] //// + +=== first.ts === +declare function flatten1(iterable: Iterable>): T[]; +>flatten1 : Symbol(flatten1, Decl(first.ts, 0, 0)) +>T : Symbol(T, Decl(first.ts, 0, 26)) +>iterable : Symbol(iterable, Decl(first.ts, 0, 29)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(first.ts, 0, 26)) +>T : Symbol(T, Decl(first.ts, 0, 26)) + +declare const lists1: string[][]; +>lists1 : Symbol(lists1, Decl(first.ts, 1, 13)) + +const flat1: null = flatten1(lists1); +>flat1 : Symbol(flat1, Decl(first.ts, 2, 5)) +>flatten1 : Symbol(flatten1, Decl(first.ts, 0, 0)) +>lists1 : Symbol(lists1, Decl(first.ts, 1, 13)) + +declare const items1: string[]; +>items1 : Symbol(items1, Decl(first.ts, 4, 13)) + +for (const item of items1) {} +>item : Symbol(item, Decl(first.ts, 5, 10)) +>items1 : Symbol(items1, Decl(first.ts, 4, 13)) + +=== second.ts === +declare const items2: number[]; +>items2 : Symbol(items2, Decl(second.ts, 0, 13)) + +for (const item of items2) {} +>item : Symbol(item, Decl(second.ts, 1, 10)) +>items2 : Symbol(items2, Decl(second.ts, 0, 13)) + +declare function flatten2(iterable: Iterable>): T[]; +>flatten2 : Symbol(flatten2, Decl(second.ts, 1, 29)) +>T : Symbol(T, Decl(second.ts, 3, 26)) +>iterable : Symbol(iterable, Decl(second.ts, 3, 29)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(second.ts, 3, 26)) +>T : Symbol(T, Decl(second.ts, 3, 26)) + +declare const lists2: number[][]; +>lists2 : Symbol(lists2, Decl(second.ts, 4, 13)) + +const flat2: null = flatten2(lists2); +>flat2 : Symbol(flat2, Decl(second.ts, 5, 5)) +>flatten2 : Symbol(flatten2, Decl(second.ts, 1, 29)) +>lists2 : Symbol(lists2, Decl(second.ts, 4, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types new file mode 100644 index 0000000000000..a4b3f46e454aa --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/inferenceDeeplyNestedCheckOrder.ts] //// + +=== first.ts === +declare function flatten1(iterable: Iterable>): T[]; +>flatten1 : (iterable: Iterable>) => T[] +>iterable : Iterable> + +declare const lists1: string[][]; +>lists1 : string[][] + +const flat1: null = flatten1(lists1); +>flat1 : null +>flatten1(lists1) : string[] +>flatten1 : (iterable: Iterable>) => T[] +>lists1 : string[][] + +declare const items1: string[]; +>items1 : string[] + +for (const item of items1) {} +>item : string +>items1 : string[] + +=== second.ts === +declare const items2: number[]; +>items2 : number[] + +for (const item of items2) {} +>item : number +>items2 : number[] + +declare function flatten2(iterable: Iterable>): T[]; +>flatten2 : (iterable: Iterable>) => T[] +>iterable : Iterable> + +declare const lists2: number[][]; +>lists2 : number[][] + +const flat2: null = flatten2(lists2); +>flat2 : null +>flatten2(lists2) : number[] +>flatten2 : (iterable: Iterable>) => T[] +>lists2 : number[][] + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.symbols b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.symbols new file mode 100644 index 0000000000000..981fb64862427 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts] //// + +=== inferenceFromUnionOfTypeParameterAndPromiseLike.ts === +// Inferring from Promise to PromiseLike | V must infer V as string, +// whichever order the union's members are in. + +declare function props(x: PromiseLike | V>>): Promise>; +>props : Symbol(props, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 0, 0)) +>K : Symbol(K, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 23)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) +>x : Symbol(x, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 29)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>K : Symbol(K, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 23)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>K : Symbol(K, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 23)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) + +declare const input: Promise>>; +>input : Symbol(input, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 4, 13)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) + +const out: Promise> = props(input); +>out : Symbol(out, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 5, 5)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>props : Symbol(props, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 0, 0)) +>input : Symbol(input, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 4, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types new file mode 100644 index 0000000000000..9c53d108ea674 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts] //// + +=== inferenceFromUnionOfTypeParameterAndPromiseLike.ts === +// Inferring from Promise to PromiseLike | V must infer V as string, +// whichever order the union's members are in. + +declare function props(x: PromiseLike | V>>): Promise>; +>props : (x: PromiseLike | V>>) => Promise> +>x : PromiseLike>> + +declare const input: Promise>>; +>input : Promise>> + +const out: Promise> = props(input); +>out : Promise> +>props(input) : Promise> +>props : (x: PromiseLike | V>>) => Promise> +>input : Promise>> + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.symbols b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.symbols new file mode 100644 index 0000000000000..9e92b4fcae85c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.symbols @@ -0,0 +1,65 @@ +//// [tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts] //// + +=== inferenceThroughSortOfFlattenedIterable.ts === +// Sorting the array made from a flattened iterable must keep its element type. + +function getAllValuesUnsorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesUnsorted : Symbol(getAllValuesUnsorted, Decl(inferenceThroughSortOfFlattenedIterable.ts, 0, 0)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 2, 30)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) + + // OK + return Array.from(flatten(m.values())) +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>flatten : Symbol(flatten, Decl(inferenceThroughSortOfFlattenedIterable.ts, 10, 1)) +>m.values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 2, 30)) +>values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +} + +function getAllValuesSorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesSorted : Symbol(getAllValuesSorted, Decl(inferenceThroughSortOfFlattenedIterable.ts, 5, 1)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 7, 28)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) + + // Type 'unknown[]' is not assignable to type 'readonly string[]'. + return Array.from(flatten(m.values())).sort() +>Array.from(flatten(m.values())).sort : Symbol(Array.sort, Decl(lib.es5.d.ts, --, --)) +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>flatten : Symbol(flatten, Decl(inferenceThroughSortOfFlattenedIterable.ts, 10, 1)) +>m.values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 7, 28)) +>values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>sort : Symbol(Array.sort, Decl(lib.es5.d.ts, --, --)) +} + +function* flatten(a: Iterable>): Iterable { +>flatten : Symbol(flatten, Decl(inferenceThroughSortOfFlattenedIterable.ts, 10, 1)) +>T : Symbol(T, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 18)) +>a : Symbol(a, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 21)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 18)) + + for (const xs of a) +>xs : Symbol(xs, Decl(inferenceThroughSortOfFlattenedIterable.ts, 13, 11)) +>a : Symbol(a, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 21)) + + for (const x of xs) +>x : Symbol(x, Decl(inferenceThroughSortOfFlattenedIterable.ts, 14, 12)) +>xs : Symbol(xs, Decl(inferenceThroughSortOfFlattenedIterable.ts, 13, 11)) + + yield x +>x : Symbol(x, Decl(inferenceThroughSortOfFlattenedIterable.ts, 14, 12)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types new file mode 100644 index 0000000000000..aaccfb8fcc5f4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts] //// + +=== inferenceThroughSortOfFlattenedIterable.ts === +// Sorting the array made from a flattened iterable must keep its element type. + +function getAllValuesUnsorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesUnsorted : (m: ReadonlyArray>) => ReadonlyArray +>m : readonly (readonly string[])[] + + // OK + return Array.from(flatten(m.values())) +>Array.from(flatten(m.values())) : string[] +>Array.from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>Array : ArrayConstructor +>from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>flatten(m.values()) : Iterable +>flatten : (a: Iterable>) => Iterable +>m.values() : ArrayIterator +>m.values : () => ArrayIterator +>m : readonly (readonly string[])[] +>values : () => ArrayIterator +} + +function getAllValuesSorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesSorted : (m: ReadonlyArray>) => ReadonlyArray +>m : readonly (readonly string[])[] + + // Type 'unknown[]' is not assignable to type 'readonly string[]'. + return Array.from(flatten(m.values())).sort() +>Array.from(flatten(m.values())).sort() : string[] +>Array.from(flatten(m.values())).sort : (compareFn?: ((a: string, b: string) => number) | undefined) => string[] +>Array.from(flatten(m.values())) : string[] +>Array.from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>Array : ArrayConstructor +>from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>flatten(m.values()) : Iterable +>flatten : (a: Iterable>) => Iterable +>m.values() : ArrayIterator +>m.values : () => ArrayIterator +>m : readonly (readonly string[])[] +>values : () => ArrayIterator +>sort : (compareFn?: ((a: string, b: string) => number) | undefined) => string[] +} + +function* flatten(a: Iterable>): Iterable { +>flatten : (a: Iterable>) => Iterable +>a : Iterable> + + for (const xs of a) +>xs : Iterable +>a : Iterable> + + for (const x of xs) +>x : T +>xs : Iterable + + yield x +>yield x : any +>x : T +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).symbols new file mode 100644 index 0000000000000..0031705ad6203 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) + +fromMetadata(a); +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) + +type Nested = Nested[]; +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +interface Prop { owner: Meta } +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) +>owner : Symbol(Prop.owner, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 19)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) + +interface Meta { +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + prop: Prop; +>prop : Symbol(Meta.prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 19)) +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + other: any; +>other : Symbol(Meta.other, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 12, 18)) + + query: Query; +>query : Symbol(Meta.query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 13, 15)) +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +} +type Query = { cond: Nested }; +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +>X : Symbol(X, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 11)) +>cond : Symbol(cond, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 17)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>meta : Symbol(meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 33)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).types new file mode 100644 index 0000000000000..1541a7890f5e6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Meta + +fromMetadata(a); +>fromMetadata(a) : void +>fromMetadata : (meta: Meta | DeepPartial>) => void +>a : Meta + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : DeepPartial + +type Nested = Nested[]; +>Nested : Nested + +interface Prop { owner: Meta } +>owner : Meta + +interface Meta { + prop: Prop; +>prop : Prop + + other: any; +>other : any + + query: Query; +>query : Query +} +type Query = { cond: Nested }; +>Query : Query +>cond : Nested + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : (meta: Meta | DeepPartial>) => void +>meta : DeepPartial> | Meta + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..0031705ad6203 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) + +fromMetadata(a); +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) + +type Nested = Nested[]; +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +interface Prop { owner: Meta } +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) +>owner : Symbol(Prop.owner, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 19)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) + +interface Meta { +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + prop: Prop; +>prop : Symbol(Meta.prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 19)) +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + other: any; +>other : Symbol(Meta.other, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 12, 18)) + + query: Query; +>query : Symbol(Meta.query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 13, 15)) +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +} +type Query = { cond: Nested }; +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +>X : Symbol(X, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 11)) +>cond : Symbol(cond, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 17)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>meta : Symbol(meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 33)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).types new file mode 100644 index 0000000000000..1541a7890f5e6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Meta + +fromMetadata(a); +>fromMetadata(a) : void +>fromMetadata : (meta: Meta | DeepPartial>) => void +>a : Meta + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : DeepPartial + +type Nested = Nested[]; +>Nested : Nested + +interface Prop { owner: Meta } +>owner : Meta + +interface Meta { + prop: Prop; +>prop : Prop + + other: any; +>other : any + + query: Query; +>query : Query +} +type Query = { cond: Nested }; +>Query : Query +>cond : Nested + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : (meta: Meta | DeepPartial>) => void +>meta : DeepPartial> | Meta + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..e139f88dccad8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type K = `${D}${D}${D}`; +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) + +type Rest = Wide<[0, 0], "a">; +>Rest : Symbol(Rest, Decl(instantiationCountSharedCheckOrder.ts, 7, 115)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + +type All = Wide<[], "a">; +>All : Symbol(All, Decl(instantiationCountSharedCheckOrder.ts, 8, 30)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..7df2d098a6ea2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : D + +type K = `${D}${D}${D}`; +>K : "000" | "001" | "002" | "003" | "004" | "005" | "006" | "007" | "008" | "009" | "010" | "011" | "012" | "013" | "014" | "015" | "016" | "017" | "018" | "019" | "020" | "021" | "022" | "023" | "024" | "025" | "026" | "027" | "028" | "029" | "030" | "031" | "032" | "033" | "034" | "035" | "036" | "037" | "038" | "039" | "040" | "041" | "042" | "043" | "044" | "045" | "046" | "047" | "048" | "049" | "050" | "051" | "052" | "053" | "054" | "055" | "056" | "057" | "058" | "059" | "060" | "061" | "062" | "063" | "064" | "065" | "066" | "067" | "068" | "069" | "070" | "071" | "072" | "073" | "074" | "075" | "076" | "077" | "078" | "079" | "080" | "081" | "082" | "083" | "084" | "085" | "086" | "087" | "088" | "089" | "090" | "091" | "092" | "093" | "094" | "095" | "096" | "097" | "098" | "099" | "100" | "101" | "102" | "103" | "104" | "105" | "106" | "107" | "108" | "109" | "110" | "111" | "112" | "113" | "114" | "115" | "116" | "117" | "118" | "119" | "120" | "121" | "122" | "123" | "124" | "125" | "126" | "127" | "128" | "129" | "130" | "131" | "132" | "133" | "134" | "135" | "136" | "137" | "138" | "139" | "140" | "141" | "142" | "143" | "144" | "145" | "146" | "147" | "148" | "149" | "150" | "151" | "152" | "153" | "154" | "155" | "156" | "157" | "158" | "159" | "160" | "161" | "162" | "163" | "164" | "165" | "166" | "167" | "168" | "169" | "170" | "171" | "172" | "173" | "174" | "175" | "176" | "177" | "178" | "179" | "180" | "181" | "182" | "183" | "184" | "185" | "186" | "187" | "188" | "189" | "190" | "191" | "192" | "193" | "194" | "195" | "196" | "197" | "198" | "199" | "200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299" | "300" | "301" | "302" | "303" | "304" | "305" | "306" | "307" | "308" | "309" | "310" | "311" | "312" | "313" | "314" | "315" | "316" | "317" | "318" | "319" | "320" | "321" | "322" | "323" | "324" | "325" | "326" | "327" | "328" | "329" | "330" | "331" | "332" | "333" | "334" | "335" | "336" | "337" | "338" | "339" | "340" | "341" | "342" | "343" | "344" | "345" | "346" | "347" | "348" | "349" | "350" | "351" | "352" | "353" | "354" | "355" | "356" | "357" | "358" | "359" | "360" | "361" | "362" | "363" | "364" | "365" | "366" | "367" | "368" | "369" | "370" | "371" | "372" | "373" | "374" | "375" | "376" | "377" | "378" | "379" | "380" | "381" | "382" | "383" | "384" | "385" | "386" | "387" | "388" | "389" | "390" | "391" | "392" | "393" | "394" | "395" | "396" | "397" | "398" | "399" | "400" | "401" | "402" | "403" | "404" | "405" | "406" | "407" | "408" | "409" | "410" | "411" | "412" | "413" | "414" | "415" | "416" | "417" | "418" | "419" | "420" | "421" | "422" | "423" | "424" | "425" | "426" | "427" | "428" | "429" | "430" | "431" | "432" | "433" | "434" | "435" | "436" | "437" | "438" | "439" | "440" | "441" | "442" | "443" | "444" | "445" | "446" | "447" | "448" | "449" | "450" | "451" | "452" | "453" | "454" | "455" | "456" | "457" | "458" | "459" | "460" | "461" | "462" | "463" | "464" | "465" | "466" | "467" | "468" | "469" | "470" | "471" | "472" | "473" | "474" | "475" | "476" | "477" | "478" | "479" | "480" | "481" | "482" | "483" | "484" | "485" | "486" | "487" | "488" | "489" | "490" | "491" | "492" | "493" | "494" | "495" | "496" | "497" | "498" | "499" | "500" | "501" | "502" | "503" | "504" | "505" | "506" | "507" | "508" | "509" | "510" | "511" | "512" | "513" | "514" | "515" | "516" | "517" | "518" | "519" | "520" | "521" | "522" | "523" | "524" | "525" | "526" | "527" | "528" | "529" | "530" | "531" | "532" | "533" | "534" | "535" | "536" | "537" | "538" | "539" | "540" | "541" | "542" | "543" | "544" | "545" | "546" | "547" | "548" | "549" | "550" | "551" | "552" | "553" | "554" | "555" | "556" | "557" | "558" | "559" | "560" | "561" | "562" | "563" | "564" | "565" | "566" | "567" | "568" | "569" | "570" | "571" | "572" | "573" | "574" | "575" | "576" | "577" | "578" | "579" | "580" | "581" | "582" | "583" | "584" | "585" | "586" | "587" | "588" | "589" | "590" | "591" | "592" | "593" | "594" | "595" | "596" | "597" | "598" | "599" | "600" | "601" | "602" | "603" | "604" | "605" | "606" | "607" | "608" | "609" | "610" | "611" | "612" | "613" | "614" | "615" | "616" | "617" | "618" | "619" | "620" | "621" | "622" | "623" | "624" | "625" | "626" | "627" | "628" | "629" | "630" | "631" | "632" | "633" | "634" | "635" | "636" | "637" | "638" | "639" | "640" | "641" | "642" | "643" | "644" | "645" | "646" | "647" | "648" | "649" | "650" | "651" | "652" | "653" | "654" | "655" | "656" | "657" | "658" | "659" | "660" | "661" | "662" | "663" | "664" | "665" | "666" | "667" | "668" | "669" | "670" | "671" | "672" | "673" | "674" | "675" | "676" | "677" | "678" | "679" | "680" | "681" | "682" | "683" | "684" | "685" | "686" | "687" | "688" | "689" | "690" | "691" | "692" | "693" | "694" | "695" | "696" | "697" | "698" | "699" | "700" | "701" | "702" | "703" | "704" | "705" | "706" | "707" | "708" | "709" | "710" | "711" | "712" | "713" | "714" | "715" | "716" | "717" | "718" | "719" | "720" | "721" | "722" | "723" | "724" | "725" | "726" | "727" | "728" | "729" | "730" | "731" | "732" | "733" | "734" | "735" | "736" | "737" | "738" | "739" | "740" | "741" | "742" | "743" | "744" | "745" | "746" | "747" | "748" | "749" | "750" | "751" | "752" | "753" | "754" | "755" | "756" | "757" | "758" | "759" | "760" | "761" | "762" | "763" | "764" | "765" | "766" | "767" | "768" | "769" | "770" | "771" | "772" | "773" | "774" | "775" | "776" | "777" | "778" | "779" | "780" | "781" | "782" | "783" | "784" | "785" | "786" | "787" | "788" | "789" | "790" | "791" | "792" | "793" | "794" | "795" | "796" | "797" | "798" | "799" | "800" | "801" | "802" | "803" | "804" | "805" | "806" | "807" | "808" | "809" | "810" | "811" | "812" | "813" | "814" | "815" | "816" | "817" | "818" | "819" | "820" | "821" | "822" | "823" | "824" | "825" | "826" | "827" | "828" | "829" | "830" | "831" | "832" | "833" | "834" | "835" | "836" | "837" | "838" | "839" | "840" | "841" | "842" | "843" | "844" | "845" | "846" | "847" | "848" | "849" | "850" | "851" | "852" | "853" | "854" | "855" | "856" | "857" | "858" | "859" | "860" | "861" | "862" | "863" | "864" | "865" | "866" | "867" | "868" | "869" | "870" | "871" | "872" | "873" | "874" | "875" | "876" | "877" | "878" | "879" | "880" | "881" | "882" | "883" | "884" | "885" | "886" | "887" | "888" | "889" | "890" | "891" | "892" | "893" | "894" | "895" | "896" | "897" | "898" | "899" | "900" | "901" | "902" | "903" | "904" | "905" | "906" | "907" | "908" | "909" | "910" | "911" | "912" | "913" | "914" | "915" | "916" | "917" | "918" | "919" | "920" | "921" | "922" | "923" | "924" | "925" | "926" | "927" | "928" | "929" | "930" | "931" | "932" | "933" | "934" | "935" | "936" | "937" | "938" | "939" | "940" | "941" | "942" | "943" | "944" | "945" | "946" | "947" | "948" | "949" | "950" | "951" | "952" | "953" | "954" | "955" | "956" | "957" | "958" | "959" | "960" | "961" | "962" | "963" | "964" | "965" | "966" | "967" | "968" | "969" | "970" | "971" | "972" | "973" | "974" | "975" | "976" | "977" | "978" | "979" | "980" | "981" | "982" | "983" | "984" | "985" | "986" | "987" | "988" | "989" | "990" | "991" | "992" | "993" | "994" | "995" | "996" | "997" | "998" | "999" + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Wide + +type Rest = Wide<[0, 0], "a">; +>Rest : ["a", "000"] | ["a", "001"] | ["a", "002"] | ["a", "003"] | ["a", "004"] | ["a", "005"] | ["a", "006"] | ["a", "007"] | ["a", "008"] | ["a", "009"] | ["a", "010"] | ["a", "011"] | ["a", "012"] | ["a", "013"] | ["a", "014"] | ["a", "015"] | ["a", "016"] | ["a", "017"] | ["a", "018"] | ["a", "019"] | ["a", "020"] | ["a", "021"] | ["a", "022"] | ["a", "023"] | ["a", "024"] | ["a", "025"] | ["a", "026"] | ["a", "027"] | ["a", "028"] | ["a", "029"] | ["a", "030"] | ["a", "031"] | ["a", "032"] | ["a", "033"] | ["a", "034"] | ["a", "035"] | ["a", "036"] | ["a", "037"] | ["a", "038"] | ["a", "039"] | ["a", "040"] | ["a", "041"] | ["a", "042"] | ["a", "043"] | ["a", "044"] | ["a", "045"] | ["a", "046"] | ["a", "047"] | ["a", "048"] | ["a", "049"] | ["a", "050"] | ["a", "051"] | ["a", "052"] | ["a", "053"] | ["a", "054"] | ["a", "055"] | ["a", "056"] | ["a", "057"] | ["a", "058"] | ["a", "059"] | ["a", "060"] | ["a", "061"] | ["a", "062"] | ["a", "063"] | ["a", "064"] | ["a", "065"] | ["a", "066"] | ["a", "067"] | ["a", "068"] | ["a", "069"] | ["a", "070"] | ["a", "071"] | ["a", "072"] | ["a", "073"] | ["a", "074"] | ["a", "075"] | ["a", "076"] | ["a", "077"] | ["a", "078"] | ["a", "079"] | ["a", "080"] | ["a", "081"] | ["a", "082"] | ["a", "083"] | ["a", "084"] | ["a", "085"] | ["a", "086"] | ["a", "087"] | ["a", "088"] | ["a", "089"] | ["a", "090"] | ["a", "091"] | ["a", "092"] | ["a", "093"] | ["a", "094"] | ["a", "095"] | ["a", "096"] | ["a", "097"] | ["a", "098"] | ["a", "099"] | ["a", "100"] | ["a", "101"] | ["a", "102"] | ["a", "103"] | ["a", "104"] | ["a", "105"] | ["a", "106"] | ["a", "107"] | ["a", "108"] | ["a", "109"] | ["a", "110"] | ["a", "111"] | ["a", "112"] | ["a", "113"] | ["a", "114"] | ["a", "115"] | ["a", "116"] | ["a", "117"] | ["a", "118"] | ["a", "119"] | ["a", "120"] | ["a", "121"] | ["a", "122"] | ["a", "123"] | ["a", "124"] | ["a", "125"] | ["a", "126"] | ["a", "127"] | ["a", "128"] | ["a", "129"] | ["a", "130"] | ["a", "131"] | ["a", "132"] | ["a", "133"] | ["a", "134"] | ["a", "135"] | ["a", "136"] | ["a", "137"] | ["a", "138"] | ["a", "139"] | ["a", "140"] | ["a", "141"] | ["a", "142"] | ["a", "143"] | ["a", "144"] | ["a", "145"] | ["a", "146"] | ["a", "147"] | ["a", "148"] | ["a", "149"] | ["a", "150"] | ["a", "151"] | ["a", "152"] | ["a", "153"] | ["a", "154"] | ["a", "155"] | ["a", "156"] | ["a", "157"] | ["a", "158"] | ["a", "159"] | ["a", "160"] | ["a", "161"] | ["a", "162"] | ["a", "163"] | ["a", "164"] | ["a", "165"] | ["a", "166"] | ["a", "167"] | ["a", "168"] | ["a", "169"] | ["a", "170"] | ["a", "171"] | ["a", "172"] | ["a", "173"] | ["a", "174"] | ["a", "175"] | ["a", "176"] | ["a", "177"] | ["a", "178"] | ["a", "179"] | ["a", "180"] | ["a", "181"] | ["a", "182"] | ["a", "183"] | ["a", "184"] | ["a", "185"] | ["a", "186"] | ["a", "187"] | ["a", "188"] | ["a", "189"] | ["a", "190"] | ["a", "191"] | ["a", "192"] | ["a", "193"] | ["a", "194"] | ["a", "195"] | ["a", "196"] | ["a", "197"] | ["a", "198"] | ["a", "199"] | ["a", "200"] | ["a", "201"] | ["a", "202"] | ["a", "203"] | ["a", "204"] | ["a", "205"] | ["a", "206"] | ["a", "207"] | ["a", "208"] | ["a", "209"] | ["a", "210"] | ["a", "211"] | ["a", "212"] | ["a", "213"] | ["a", "214"] | ["a", "215"] | ["a", "216"] | ["a", "217"] | ["a", "218"] | ["a", "219"] | ["a", "220"] | ["a", "221"] | ["a", "222"] | ["a", "223"] | ["a", "224"] | ["a", "225"] | ["a", "226"] | ["a", "227"] | ["a", "228"] | ["a", "229"] | ["a", "230"] | ["a", "231"] | ["a", "232"] | ["a", "233"] | ["a", "234"] | ["a", "235"] | ["a", "236"] | ["a", "237"] | ["a", "238"] | ["a", "239"] | ["a", "240"] | ["a", "241"] | ["a", "242"] | ["a", "243"] | ["a", "244"] | ["a", "245"] | ["a", "246"] | ["a", "247"] | ["a", "248"] | ["a", "249"] | ["a", "250"] | ["a", "251"] | ["a", "252"] | ["a", "253"] | ["a", "254"] | ["a", "255"] | ["a", "256"] | ["a", "257"] | ["a", "258"] | ["a", "259"] | ["a", "260"] | ["a", "261"] | ["a", "262"] | ["a", "263"] | ["a", "264"] | ["a", "265"] | ["a", "266"] | ["a", "267"] | ["a", "268"] | ["a", "269"] | ["a", "270"] | ["a", "271"] | ["a", "272"] | ["a", "273"] | ["a", "274"] | ["a", "275"] | ["a", "276"] | ["a", "277"] | ["a", "278"] | ["a", "279"] | ["a", "280"] | ["a", "281"] | ["a", "282"] | ["a", "283"] | ["a", "284"] | ["a", "285"] | ["a", "286"] | ["a", "287"] | ["a", "288"] | ["a", "289"] | ["a", "290"] | ["a", "291"] | ["a", "292"] | ["a", "293"] | ["a", "294"] | ["a", "295"] | ["a", "296"] | ["a", "297"] | ["a", "298"] | ["a", "299"] | ["a", "300"] | ["a", "301"] | ["a", "302"] | ["a", "303"] | ["a", "304"] | ["a", "305"] | ["a", "306"] | ["a", "307"] | ["a", "308"] | ["a", "309"] | ["a", "310"] | ["a", "311"] | ["a", "312"] | ["a", "313"] | ["a", "314"] | ["a", "315"] | ["a", "316"] | ["a", "317"] | ["a", "318"] | ["a", "319"] | ["a", "320"] | ["a", "321"] | ["a", "322"] | ["a", "323"] | ["a", "324"] | ["a", "325"] | ["a", "326"] | ["a", "327"] | ["a", "328"] | ["a", "329"] | ["a", "330"] | ["a", "331"] | ["a", "332"] | ["a", "333"] | ["a", "334"] | ["a", "335"] | ["a", "336"] | ["a", "337"] | ["a", "338"] | ["a", "339"] | ["a", "340"] | ["a", "341"] | ["a", "342"] | ["a", "343"] | ["a", "344"] | ["a", "345"] | ["a", "346"] | ["a", "347"] | ["a", "348"] | ["a", "349"] | ["a", "350"] | ["a", "351"] | ["a", "352"] | ["a", "353"] | ["a", "354"] | ["a", "355"] | ["a", "356"] | ["a", "357"] | ["a", "358"] | ["a", "359"] | ["a", "360"] | ["a", "361"] | ["a", "362"] | ["a", "363"] | ["a", "364"] | ["a", "365"] | ["a", "366"] | ["a", "367"] | ["a", "368"] | ["a", "369"] | ["a", "370"] | ["a", "371"] | ["a", "372"] | ["a", "373"] | ["a", "374"] | ["a", "375"] | ["a", "376"] | ["a", "377"] | ["a", "378"] | ["a", "379"] | ["a", "380"] | ["a", "381"] | ["a", "382"] | ["a", "383"] | ["a", "384"] | ["a", "385"] | ["a", "386"] | ["a", "387"] | ["a", "388"] | ["a", "389"] | ["a", "390"] | ["a", "391"] | ["a", "392"] | ["a", "393"] | ["a", "394"] | ["a", "395"] | ["a", "396"] | ["a", "397"] | ["a", "398"] | ["a", "399"] | ["a", "400"] | ["a", "401"] | ["a", "402"] | ["a", "403"] | ["a", "404"] | ["a", "405"] | ["a", "406"] | ["a", "407"] | ["a", "408"] | ["a", "409"] | ["a", "410"] | ["a", "411"] | ["a", "412"] | ["a", "413"] | ["a", "414"] | ["a", "415"] | ["a", "416"] | ["a", "417"] | ["a", "418"] | ["a", "419"] | ["a", "420"] | ["a", "421"] | ["a", "422"] | ["a", "423"] | ["a", "424"] | ["a", "425"] | ["a", "426"] | ["a", "427"] | ["a", "428"] | ["a", "429"] | ["a", "430"] | ["a", "431"] | ["a", "432"] | ["a", "433"] | ["a", "434"] | ["a", "435"] | ["a", "436"] | ["a", "437"] | ["a", "438"] | ["a", "439"] | ["a", "440"] | ["a", "441"] | ["a", "442"] | ["a", "443"] | ["a", "444"] | ["a", "445"] | ["a", "446"] | ["a", "447"] | ["a", "448"] | ["a", "449"] | ["a", "450"] | ["a", "451"] | ["a", "452"] | ["a", "453"] | ["a", "454"] | ["a", "455"] | ["a", "456"] | ["a", "457"] | ["a", "458"] | ["a", "459"] | ["a", "460"] | ["a", "461"] | ["a", "462"] | ["a", "463"] | ["a", "464"] | ["a", "465"] | ["a", "466"] | ["a", "467"] | ["a", "468"] | ["a", "469"] | ["a", "470"] | ["a", "471"] | ["a", "472"] | ["a", "473"] | ["a", "474"] | ["a", "475"] | ["a", "476"] | ["a", "477"] | ["a", "478"] | ["a", "479"] | ["a", "480"] | ["a", "481"] | ["a", "482"] | ["a", "483"] | ["a", "484"] | ["a", "485"] | ["a", "486"] | ["a", "487"] | ["a", "488"] | ["a", "489"] | ["a", "490"] | ["a", "491"] | ["a", "492"] | ["a", "493"] | ["a", "494"] | ["a", "495"] | ["a", "496"] | ["a", "497"] | ["a", "498"] | ["a", "499"] | ["a", "500"] | ["a", "501"] | ["a", "502"] | ["a", "503"] | ["a", "504"] | ["a", "505"] | ["a", "506"] | ["a", "507"] | ["a", "508"] | ["a", "509"] | ["a", "510"] | ["a", "511"] | ["a", "512"] | ["a", "513"] | ["a", "514"] | ["a", "515"] | ["a", "516"] | ["a", "517"] | ["a", "518"] | ["a", "519"] | ["a", "520"] | ["a", "521"] | ["a", "522"] | ["a", "523"] | ["a", "524"] | ["a", "525"] | ["a", "526"] | ["a", "527"] | ["a", "528"] | ["a", "529"] | ["a", "530"] | ["a", "531"] | ["a", "532"] | ["a", "533"] | ["a", "534"] | ["a", "535"] | ["a", "536"] | ["a", "537"] | ["a", "538"] | ["a", "539"] | ["a", "540"] | ["a", "541"] | ["a", "542"] | ["a", "543"] | ["a", "544"] | ["a", "545"] | ["a", "546"] | ["a", "547"] | ["a", "548"] | ["a", "549"] | ["a", "550"] | ["a", "551"] | ["a", "552"] | ["a", "553"] | ["a", "554"] | ["a", "555"] | ["a", "556"] | ["a", "557"] | ["a", "558"] | ["a", "559"] | ["a", "560"] | ["a", "561"] | ["a", "562"] | ["a", "563"] | ["a", "564"] | ["a", "565"] | ["a", "566"] | ["a", "567"] | ["a", "568"] | ["a", "569"] | ["a", "570"] | ["a", "571"] | ["a", "572"] | ["a", "573"] | ["a", "574"] | ["a", "575"] | ["a", "576"] | ["a", "577"] | ["a", "578"] | ["a", "579"] | ["a", "580"] | ["a", "581"] | ["a", "582"] | ["a", "583"] | ["a", "584"] | ["a", "585"] | ["a", "586"] | ["a", "587"] | ["a", "588"] | ["a", "589"] | ["a", "590"] | ["a", "591"] | ["a", "592"] | ["a", "593"] | ["a", "594"] | ["a", "595"] | ["a", "596"] | ["a", "597"] | ["a", "598"] | ["a", "599"] | ["a", "600"] | ["a", "601"] | ["a", "602"] | ["a", "603"] | ["a", "604"] | ["a", "605"] | ["a", "606"] | ["a", "607"] | ["a", "608"] | ["a", "609"] | ["a", "610"] | ["a", "611"] | ["a", "612"] | ["a", "613"] | ["a", "614"] | ["a", "615"] | ["a", "616"] | ["a", "617"] | ["a", "618"] | ["a", "619"] | ["a", "620"] | ["a", "621"] | ["a", "622"] | ["a", "623"] | ["a", "624"] | ["a", "625"] | ["a", "626"] | ["a", "627"] | ["a", "628"] | ["a", "629"] | ["a", "630"] | ["a", "631"] | ["a", "632"] | ["a", "633"] | ["a", "634"] | ["a", "635"] | ["a", "636"] | ["a", "637"] | ["a", "638"] | ["a", "639"] | ["a", "640"] | ["a", "641"] | ["a", "642"] | ["a", "643"] | ["a", "644"] | ["a", "645"] | ["a", "646"] | ["a", "647"] | ["a", "648"] | ["a", "649"] | ["a", "650"] | ["a", "651"] | ["a", "652"] | ["a", "653"] | ["a", "654"] | ["a", "655"] | ["a", "656"] | ["a", "657"] | ["a", "658"] | ["a", "659"] | ["a", "660"] | ["a", "661"] | ["a", "662"] | ["a", "663"] | ["a", "664"] | ["a", "665"] | ["a", "666"] | ["a", "667"] | ["a", "668"] | ["a", "669"] | ["a", "670"] | ["a", "671"] | ["a", "672"] | ["a", "673"] | ["a", "674"] | ["a", "675"] | ["a", "676"] | ["a", "677"] | ["a", "678"] | ["a", "679"] | ["a", "680"] | ["a", "681"] | ["a", "682"] | ["a", "683"] | ["a", "684"] | ["a", "685"] | ["a", "686"] | ["a", "687"] | ["a", "688"] | ["a", "689"] | ["a", "690"] | ["a", "691"] | ["a", "692"] | ["a", "693"] | ["a", "694"] | ["a", "695"] | ["a", "696"] | ["a", "697"] | ["a", "698"] | ["a", "699"] | ["a", "700"] | ["a", "701"] | ["a", "702"] | ["a", "703"] | ["a", "704"] | ["a", "705"] | ["a", "706"] | ["a", "707"] | ["a", "708"] | ["a", "709"] | ["a", "710"] | ["a", "711"] | ["a", "712"] | ["a", "713"] | ["a", "714"] | ["a", "715"] | ["a", "716"] | ["a", "717"] | ["a", "718"] | ["a", "719"] | ["a", "720"] | ["a", "721"] | ["a", "722"] | ["a", "723"] | ["a", "724"] | ["a", "725"] | ["a", "726"] | ["a", "727"] | ["a", "728"] | ["a", "729"] | ["a", "730"] | ["a", "731"] | ["a", "732"] | ["a", "733"] | ["a", "734"] | ["a", "735"] | ["a", "736"] | ["a", "737"] | ["a", "738"] | ["a", "739"] | ["a", "740"] | ["a", "741"] | ["a", "742"] | ["a", "743"] | ["a", "744"] | ["a", "745"] | ["a", "746"] | ["a", "747"] | ["a", "748"] | ["a", "749"] | ["a", "750"] | ["a", "751"] | ["a", "752"] | ["a", "753"] | ["a", "754"] | ["a", "755"] | ["a", "756"] | ["a", "757"] | ["a", "758"] | ["a", "759"] | ["a", "760"] | ["a", "761"] | ["a", "762"] | ["a", "763"] | ["a", "764"] | ["a", "765"] | ["a", "766"] | ["a", "767"] | ["a", "768"] | ["a", "769"] | ["a", "770"] | ["a", "771"] | ["a", "772"] | ["a", "773"] | ["a", "774"] | ["a", "775"] | ["a", "776"] | ["a", "777"] | ["a", "778"] | ["a", "779"] | ["a", "780"] | ["a", "781"] | ["a", "782"] | ["a", "783"] | ["a", "784"] | ["a", "785"] | ["a", "786"] | ["a", "787"] | ["a", "788"] | ["a", "789"] | ["a", "790"] | ["a", "791"] | ["a", "792"] | ["a", "793"] | ["a", "794"] | ["a", "795"] | ["a", "796"] | ["a", "797"] | ["a", "798"] | ["a", "799"] | ["a", "800"] | ["a", "801"] | ["a", "802"] | ["a", "803"] | ["a", "804"] | ["a", "805"] | ["a", "806"] | ["a", "807"] | ["a", "808"] | ["a", "809"] | ["a", "810"] | ["a", "811"] | ["a", "812"] | ["a", "813"] | ["a", "814"] | ["a", "815"] | ["a", "816"] | ["a", "817"] | ["a", "818"] | ["a", "819"] | ["a", "820"] | ["a", "821"] | ["a", "822"] | ["a", "823"] | ["a", "824"] | ["a", "825"] | ["a", "826"] | ["a", "827"] | ["a", "828"] | ["a", "829"] | ["a", "830"] | ["a", "831"] | ["a", "832"] | ["a", "833"] | ["a", "834"] | ["a", "835"] | ["a", "836"] | ["a", "837"] | ["a", "838"] | ["a", "839"] | ["a", "840"] | ["a", "841"] | ["a", "842"] | ["a", "843"] | ["a", "844"] | ["a", "845"] | ["a", "846"] | ["a", "847"] | ["a", "848"] | ["a", "849"] | ["a", "850"] | ["a", "851"] | ["a", "852"] | ["a", "853"] | ["a", "854"] | ["a", "855"] | ["a", "856"] | ["a", "857"] | ["a", "858"] | ["a", "859"] | ["a", "860"] | ["a", "861"] | ["a", "862"] | ["a", "863"] | ["a", "864"] | ["a", "865"] | ["a", "866"] | ["a", "867"] | ["a", "868"] | ["a", "869"] | ["a", "870"] | ["a", "871"] | ["a", "872"] | ["a", "873"] | ["a", "874"] | ["a", "875"] | ["a", "876"] | ["a", "877"] | ["a", "878"] | ["a", "879"] | ["a", "880"] | ["a", "881"] | ["a", "882"] | ["a", "883"] | ["a", "884"] | ["a", "885"] | ["a", "886"] | ["a", "887"] | ["a", "888"] | ["a", "889"] | ["a", "890"] | ["a", "891"] | ["a", "892"] | ["a", "893"] | ["a", "894"] | ["a", "895"] | ["a", "896"] | ["a", "897"] | ["a", "898"] | ["a", "899"] | ["a", "900"] | ["a", "901"] | ["a", "902"] | ["a", "903"] | ["a", "904"] | ["a", "905"] | ["a", "906"] | ["a", "907"] | ["a", "908"] | ["a", "909"] | ["a", "910"] | ["a", "911"] | ["a", "912"] | ["a", "913"] | ["a", "914"] | ["a", "915"] | ["a", "916"] | ["a", "917"] | ["a", "918"] | ["a", "919"] | ["a", "920"] | ["a", "921"] | ["a", "922"] | ["a", "923"] | ["a", "924"] | ["a", "925"] | ["a", "926"] | ["a", "927"] | ["a", "928"] | ["a", "929"] | ["a", "930"] | ["a", "931"] | ["a", "932"] | ["a", "933"] | ["a", "934"] | ["a", "935"] | ["a", "936"] | ["a", "937"] | ["a", "938"] | ["a", "939"] | ["a", "940"] | ["a", "941"] | ["a", "942"] | ["a", "943"] | ["a", "944"] | ["a", "945"] | ["a", "946"] | ["a", "947"] | ["a", "948"] | ["a", "949"] | ["a", "950"] | ["a", "951"] | ["a", "952"] | ["a", "953"] | ["a", "954"] | ["a", "955"] | ["a", "956"] | ["a", "957"] | ["a", "958"] | ["a", "959"] | ["a", "960"] | ["a", "961"] | ["a", "962"] | ["a", "963"] | ["a", "964"] | ["a", "965"] | ["a", "966"] | ["a", "967"] | ["a", "968"] | ["a", "969"] | ["a", "970"] | ["a", "971"] | ["a", "972"] | ["a", "973"] | ["a", "974"] | ["a", "975"] | ["a", "976"] | ["a", "977"] | ["a", "978"] | ["a", "979"] | ["a", "980"] | ["a", "981"] | ["a", "982"] | ["a", "983"] | ["a", "984"] | ["a", "985"] | ["a", "986"] | ["a", "987"] | ["a", "988"] | ["a", "989"] | ["a", "990"] | ["a", "991"] | ["a", "992"] | ["a", "993"] | ["a", "994"] | ["a", "995"] | ["a", "996"] | ["a", "997"] | ["a", "998"] | ["a", "999"] + +type All = Wide<[], "a">; +>All : ["a", "000"] | ["a", "001"] | ["a", "002"] | ["a", "003"] | ["a", "004"] | ["a", "005"] | ["a", "006"] | ["a", "007"] | ["a", "008"] | ["a", "009"] | ["a", "010"] | ["a", "011"] | ["a", "012"] | ["a", "013"] | ["a", "014"] | ["a", "015"] | ["a", "016"] | ["a", "017"] | ["a", "018"] | ["a", "019"] | ["a", "020"] | ["a", "021"] | ["a", "022"] | ["a", "023"] | ["a", "024"] | ["a", "025"] | ["a", "026"] | ["a", "027"] | ["a", "028"] | ["a", "029"] | ["a", "030"] | ["a", "031"] | ["a", "032"] | ["a", "033"] | ["a", "034"] | ["a", "035"] | ["a", "036"] | ["a", "037"] | ["a", "038"] | ["a", "039"] | ["a", "040"] | ["a", "041"] | ["a", "042"] | ["a", "043"] | ["a", "044"] | ["a", "045"] | ["a", "046"] | ["a", "047"] | ["a", "048"] | ["a", "049"] | ["a", "050"] | ["a", "051"] | ["a", "052"] | ["a", "053"] | ["a", "054"] | ["a", "055"] | ["a", "056"] | ["a", "057"] | ["a", "058"] | ["a", "059"] | ["a", "060"] | ["a", "061"] | ["a", "062"] | ["a", "063"] | ["a", "064"] | ["a", "065"] | ["a", "066"] | ["a", "067"] | ["a", "068"] | ["a", "069"] | ["a", "070"] | ["a", "071"] | ["a", "072"] | ["a", "073"] | ["a", "074"] | ["a", "075"] | ["a", "076"] | ["a", "077"] | ["a", "078"] | ["a", "079"] | ["a", "080"] | ["a", "081"] | ["a", "082"] | ["a", "083"] | ["a", "084"] | ["a", "085"] | ["a", "086"] | ["a", "087"] | ["a", "088"] | ["a", "089"] | ["a", "090"] | ["a", "091"] | ["a", "092"] | ["a", "093"] | ["a", "094"] | ["a", "095"] | ["a", "096"] | ["a", "097"] | ["a", "098"] | ["a", "099"] | ["a", "100"] | ["a", "101"] | ["a", "102"] | ["a", "103"] | ["a", "104"] | ["a", "105"] | ["a", "106"] | ["a", "107"] | ["a", "108"] | ["a", "109"] | ["a", "110"] | ["a", "111"] | ["a", "112"] | ["a", "113"] | ["a", "114"] | ["a", "115"] | ["a", "116"] | ["a", "117"] | ["a", "118"] | ["a", "119"] | ["a", "120"] | ["a", "121"] | ["a", "122"] | ["a", "123"] | ["a", "124"] | ["a", "125"] | ["a", "126"] | ["a", "127"] | ["a", "128"] | ["a", "129"] | ["a", "130"] | ["a", "131"] | ["a", "132"] | ["a", "133"] | ["a", "134"] | ["a", "135"] | ["a", "136"] | ["a", "137"] | ["a", "138"] | ["a", "139"] | ["a", "140"] | ["a", "141"] | ["a", "142"] | ["a", "143"] | ["a", "144"] | ["a", "145"] | ["a", "146"] | ["a", "147"] | ["a", "148"] | ["a", "149"] | ["a", "150"] | ["a", "151"] | ["a", "152"] | ["a", "153"] | ["a", "154"] | ["a", "155"] | ["a", "156"] | ["a", "157"] | ["a", "158"] | ["a", "159"] | ["a", "160"] | ["a", "161"] | ["a", "162"] | ["a", "163"] | ["a", "164"] | ["a", "165"] | ["a", "166"] | ["a", "167"] | ["a", "168"] | ["a", "169"] | ["a", "170"] | ["a", "171"] | ["a", "172"] | ["a", "173"] | ["a", "174"] | ["a", "175"] | ["a", "176"] | ["a", "177"] | ["a", "178"] | ["a", "179"] | ["a", "180"] | ["a", "181"] | ["a", "182"] | ["a", "183"] | ["a", "184"] | ["a", "185"] | ["a", "186"] | ["a", "187"] | ["a", "188"] | ["a", "189"] | ["a", "190"] | ["a", "191"] | ["a", "192"] | ["a", "193"] | ["a", "194"] | ["a", "195"] | ["a", "196"] | ["a", "197"] | ["a", "198"] | ["a", "199"] | ["a", "200"] | ["a", "201"] | ["a", "202"] | ["a", "203"] | ["a", "204"] | ["a", "205"] | ["a", "206"] | ["a", "207"] | ["a", "208"] | ["a", "209"] | ["a", "210"] | ["a", "211"] | ["a", "212"] | ["a", "213"] | ["a", "214"] | ["a", "215"] | ["a", "216"] | ["a", "217"] | ["a", "218"] | ["a", "219"] | ["a", "220"] | ["a", "221"] | ["a", "222"] | ["a", "223"] | ["a", "224"] | ["a", "225"] | ["a", "226"] | ["a", "227"] | ["a", "228"] | ["a", "229"] | ["a", "230"] | ["a", "231"] | ["a", "232"] | ["a", "233"] | ["a", "234"] | ["a", "235"] | ["a", "236"] | ["a", "237"] | ["a", "238"] | ["a", "239"] | ["a", "240"] | ["a", "241"] | ["a", "242"] | ["a", "243"] | ["a", "244"] | ["a", "245"] | ["a", "246"] | ["a", "247"] | ["a", "248"] | ["a", "249"] | ["a", "250"] | ["a", "251"] | ["a", "252"] | ["a", "253"] | ["a", "254"] | ["a", "255"] | ["a", "256"] | ["a", "257"] | ["a", "258"] | ["a", "259"] | ["a", "260"] | ["a", "261"] | ["a", "262"] | ["a", "263"] | ["a", "264"] | ["a", "265"] | ["a", "266"] | ["a", "267"] | ["a", "268"] | ["a", "269"] | ["a", "270"] | ["a", "271"] | ["a", "272"] | ["a", "273"] | ["a", "274"] | ["a", "275"] | ["a", "276"] | ["a", "277"] | ["a", "278"] | ["a", "279"] | ["a", "280"] | ["a", "281"] | ["a", "282"] | ["a", "283"] | ["a", "284"] | ["a", "285"] | ["a", "286"] | ["a", "287"] | ["a", "288"] | ["a", "289"] | ["a", "290"] | ["a", "291"] | ["a", "292"] | ["a", "293"] | ["a", "294"] | ["a", "295"] | ["a", "296"] | ["a", "297"] | ["a", "298"] | ["a", "299"] | ["a", "300"] | ["a", "301"] | ["a", "302"] | ["a", "303"] | ["a", "304"] | ["a", "305"] | ["a", "306"] | ["a", "307"] | ["a", "308"] | ["a", "309"] | ["a", "310"] | ["a", "311"] | ["a", "312"] | ["a", "313"] | ["a", "314"] | ["a", "315"] | ["a", "316"] | ["a", "317"] | ["a", "318"] | ["a", "319"] | ["a", "320"] | ["a", "321"] | ["a", "322"] | ["a", "323"] | ["a", "324"] | ["a", "325"] | ["a", "326"] | ["a", "327"] | ["a", "328"] | ["a", "329"] | ["a", "330"] | ["a", "331"] | ["a", "332"] | ["a", "333"] | ["a", "334"] | ["a", "335"] | ["a", "336"] | ["a", "337"] | ["a", "338"] | ["a", "339"] | ["a", "340"] | ["a", "341"] | ["a", "342"] | ["a", "343"] | ["a", "344"] | ["a", "345"] | ["a", "346"] | ["a", "347"] | ["a", "348"] | ["a", "349"] | ["a", "350"] | ["a", "351"] | ["a", "352"] | ["a", "353"] | ["a", "354"] | ["a", "355"] | ["a", "356"] | ["a", "357"] | ["a", "358"] | ["a", "359"] | ["a", "360"] | ["a", "361"] | ["a", "362"] | ["a", "363"] | ["a", "364"] | ["a", "365"] | ["a", "366"] | ["a", "367"] | ["a", "368"] | ["a", "369"] | ["a", "370"] | ["a", "371"] | ["a", "372"] | ["a", "373"] | ["a", "374"] | ["a", "375"] | ["a", "376"] | ["a", "377"] | ["a", "378"] | ["a", "379"] | ["a", "380"] | ["a", "381"] | ["a", "382"] | ["a", "383"] | ["a", "384"] | ["a", "385"] | ["a", "386"] | ["a", "387"] | ["a", "388"] | ["a", "389"] | ["a", "390"] | ["a", "391"] | ["a", "392"] | ["a", "393"] | ["a", "394"] | ["a", "395"] | ["a", "396"] | ["a", "397"] | ["a", "398"] | ["a", "399"] | ["a", "400"] | ["a", "401"] | ["a", "402"] | ["a", "403"] | ["a", "404"] | ["a", "405"] | ["a", "406"] | ["a", "407"] | ["a", "408"] | ["a", "409"] | ["a", "410"] | ["a", "411"] | ["a", "412"] | ["a", "413"] | ["a", "414"] | ["a", "415"] | ["a", "416"] | ["a", "417"] | ["a", "418"] | ["a", "419"] | ["a", "420"] | ["a", "421"] | ["a", "422"] | ["a", "423"] | ["a", "424"] | ["a", "425"] | ["a", "426"] | ["a", "427"] | ["a", "428"] | ["a", "429"] | ["a", "430"] | ["a", "431"] | ["a", "432"] | ["a", "433"] | ["a", "434"] | ["a", "435"] | ["a", "436"] | ["a", "437"] | ["a", "438"] | ["a", "439"] | ["a", "440"] | ["a", "441"] | ["a", "442"] | ["a", "443"] | ["a", "444"] | ["a", "445"] | ["a", "446"] | ["a", "447"] | ["a", "448"] | ["a", "449"] | ["a", "450"] | ["a", "451"] | ["a", "452"] | ["a", "453"] | ["a", "454"] | ["a", "455"] | ["a", "456"] | ["a", "457"] | ["a", "458"] | ["a", "459"] | ["a", "460"] | ["a", "461"] | ["a", "462"] | ["a", "463"] | ["a", "464"] | ["a", "465"] | ["a", "466"] | ["a", "467"] | ["a", "468"] | ["a", "469"] | ["a", "470"] | ["a", "471"] | ["a", "472"] | ["a", "473"] | ["a", "474"] | ["a", "475"] | ["a", "476"] | ["a", "477"] | ["a", "478"] | ["a", "479"] | ["a", "480"] | ["a", "481"] | ["a", "482"] | ["a", "483"] | ["a", "484"] | ["a", "485"] | ["a", "486"] | ["a", "487"] | ["a", "488"] | ["a", "489"] | ["a", "490"] | ["a", "491"] | ["a", "492"] | ["a", "493"] | ["a", "494"] | ["a", "495"] | ["a", "496"] | ["a", "497"] | ["a", "498"] | ["a", "499"] | ["a", "500"] | ["a", "501"] | ["a", "502"] | ["a", "503"] | ["a", "504"] | ["a", "505"] | ["a", "506"] | ["a", "507"] | ["a", "508"] | ["a", "509"] | ["a", "510"] | ["a", "511"] | ["a", "512"] | ["a", "513"] | ["a", "514"] | ["a", "515"] | ["a", "516"] | ["a", "517"] | ["a", "518"] | ["a", "519"] | ["a", "520"] | ["a", "521"] | ["a", "522"] | ["a", "523"] | ["a", "524"] | ["a", "525"] | ["a", "526"] | ["a", "527"] | ["a", "528"] | ["a", "529"] | ["a", "530"] | ["a", "531"] | ["a", "532"] | ["a", "533"] | ["a", "534"] | ["a", "535"] | ["a", "536"] | ["a", "537"] | ["a", "538"] | ["a", "539"] | ["a", "540"] | ["a", "541"] | ["a", "542"] | ["a", "543"] | ["a", "544"] | ["a", "545"] | ["a", "546"] | ["a", "547"] | ["a", "548"] | ["a", "549"] | ["a", "550"] | ["a", "551"] | ["a", "552"] | ["a", "553"] | ["a", "554"] | ["a", "555"] | ["a", "556"] | ["a", "557"] | ["a", "558"] | ["a", "559"] | ["a", "560"] | ["a", "561"] | ["a", "562"] | ["a", "563"] | ["a", "564"] | ["a", "565"] | ["a", "566"] | ["a", "567"] | ["a", "568"] | ["a", "569"] | ["a", "570"] | ["a", "571"] | ["a", "572"] | ["a", "573"] | ["a", "574"] | ["a", "575"] | ["a", "576"] | ["a", "577"] | ["a", "578"] | ["a", "579"] | ["a", "580"] | ["a", "581"] | ["a", "582"] | ["a", "583"] | ["a", "584"] | ["a", "585"] | ["a", "586"] | ["a", "587"] | ["a", "588"] | ["a", "589"] | ["a", "590"] | ["a", "591"] | ["a", "592"] | ["a", "593"] | ["a", "594"] | ["a", "595"] | ["a", "596"] | ["a", "597"] | ["a", "598"] | ["a", "599"] | ["a", "600"] | ["a", "601"] | ["a", "602"] | ["a", "603"] | ["a", "604"] | ["a", "605"] | ["a", "606"] | ["a", "607"] | ["a", "608"] | ["a", "609"] | ["a", "610"] | ["a", "611"] | ["a", "612"] | ["a", "613"] | ["a", "614"] | ["a", "615"] | ["a", "616"] | ["a", "617"] | ["a", "618"] | ["a", "619"] | ["a", "620"] | ["a", "621"] | ["a", "622"] | ["a", "623"] | ["a", "624"] | ["a", "625"] | ["a", "626"] | ["a", "627"] | ["a", "628"] | ["a", "629"] | ["a", "630"] | ["a", "631"] | ["a", "632"] | ["a", "633"] | ["a", "634"] | ["a", "635"] | ["a", "636"] | ["a", "637"] | ["a", "638"] | ["a", "639"] | ["a", "640"] | ["a", "641"] | ["a", "642"] | ["a", "643"] | ["a", "644"] | ["a", "645"] | ["a", "646"] | ["a", "647"] | ["a", "648"] | ["a", "649"] | ["a", "650"] | ["a", "651"] | ["a", "652"] | ["a", "653"] | ["a", "654"] | ["a", "655"] | ["a", "656"] | ["a", "657"] | ["a", "658"] | ["a", "659"] | ["a", "660"] | ["a", "661"] | ["a", "662"] | ["a", "663"] | ["a", "664"] | ["a", "665"] | ["a", "666"] | ["a", "667"] | ["a", "668"] | ["a", "669"] | ["a", "670"] | ["a", "671"] | ["a", "672"] | ["a", "673"] | ["a", "674"] | ["a", "675"] | ["a", "676"] | ["a", "677"] | ["a", "678"] | ["a", "679"] | ["a", "680"] | ["a", "681"] | ["a", "682"] | ["a", "683"] | ["a", "684"] | ["a", "685"] | ["a", "686"] | ["a", "687"] | ["a", "688"] | ["a", "689"] | ["a", "690"] | ["a", "691"] | ["a", "692"] | ["a", "693"] | ["a", "694"] | ["a", "695"] | ["a", "696"] | ["a", "697"] | ["a", "698"] | ["a", "699"] | ["a", "700"] | ["a", "701"] | ["a", "702"] | ["a", "703"] | ["a", "704"] | ["a", "705"] | ["a", "706"] | ["a", "707"] | ["a", "708"] | ["a", "709"] | ["a", "710"] | ["a", "711"] | ["a", "712"] | ["a", "713"] | ["a", "714"] | ["a", "715"] | ["a", "716"] | ["a", "717"] | ["a", "718"] | ["a", "719"] | ["a", "720"] | ["a", "721"] | ["a", "722"] | ["a", "723"] | ["a", "724"] | ["a", "725"] | ["a", "726"] | ["a", "727"] | ["a", "728"] | ["a", "729"] | ["a", "730"] | ["a", "731"] | ["a", "732"] | ["a", "733"] | ["a", "734"] | ["a", "735"] | ["a", "736"] | ["a", "737"] | ["a", "738"] | ["a", "739"] | ["a", "740"] | ["a", "741"] | ["a", "742"] | ["a", "743"] | ["a", "744"] | ["a", "745"] | ["a", "746"] | ["a", "747"] | ["a", "748"] | ["a", "749"] | ["a", "750"] | ["a", "751"] | ["a", "752"] | ["a", "753"] | ["a", "754"] | ["a", "755"] | ["a", "756"] | ["a", "757"] | ["a", "758"] | ["a", "759"] | ["a", "760"] | ["a", "761"] | ["a", "762"] | ["a", "763"] | ["a", "764"] | ["a", "765"] | ["a", "766"] | ["a", "767"] | ["a", "768"] | ["a", "769"] | ["a", "770"] | ["a", "771"] | ["a", "772"] | ["a", "773"] | ["a", "774"] | ["a", "775"] | ["a", "776"] | ["a", "777"] | ["a", "778"] | ["a", "779"] | ["a", "780"] | ["a", "781"] | ["a", "782"] | ["a", "783"] | ["a", "784"] | ["a", "785"] | ["a", "786"] | ["a", "787"] | ["a", "788"] | ["a", "789"] | ["a", "790"] | ["a", "791"] | ["a", "792"] | ["a", "793"] | ["a", "794"] | ["a", "795"] | ["a", "796"] | ["a", "797"] | ["a", "798"] | ["a", "799"] | ["a", "800"] | ["a", "801"] | ["a", "802"] | ["a", "803"] | ["a", "804"] | ["a", "805"] | ["a", "806"] | ["a", "807"] | ["a", "808"] | ["a", "809"] | ["a", "810"] | ["a", "811"] | ["a", "812"] | ["a", "813"] | ["a", "814"] | ["a", "815"] | ["a", "816"] | ["a", "817"] | ["a", "818"] | ["a", "819"] | ["a", "820"] | ["a", "821"] | ["a", "822"] | ["a", "823"] | ["a", "824"] | ["a", "825"] | ["a", "826"] | ["a", "827"] | ["a", "828"] | ["a", "829"] | ["a", "830"] | ["a", "831"] | ["a", "832"] | ["a", "833"] | ["a", "834"] | ["a", "835"] | ["a", "836"] | ["a", "837"] | ["a", "838"] | ["a", "839"] | ["a", "840"] | ["a", "841"] | ["a", "842"] | ["a", "843"] | ["a", "844"] | ["a", "845"] | ["a", "846"] | ["a", "847"] | ["a", "848"] | ["a", "849"] | ["a", "850"] | ["a", "851"] | ["a", "852"] | ["a", "853"] | ["a", "854"] | ["a", "855"] | ["a", "856"] | ["a", "857"] | ["a", "858"] | ["a", "859"] | ["a", "860"] | ["a", "861"] | ["a", "862"] | ["a", "863"] | ["a", "864"] | ["a", "865"] | ["a", "866"] | ["a", "867"] | ["a", "868"] | ["a", "869"] | ["a", "870"] | ["a", "871"] | ["a", "872"] | ["a", "873"] | ["a", "874"] | ["a", "875"] | ["a", "876"] | ["a", "877"] | ["a", "878"] | ["a", "879"] | ["a", "880"] | ["a", "881"] | ["a", "882"] | ["a", "883"] | ["a", "884"] | ["a", "885"] | ["a", "886"] | ["a", "887"] | ["a", "888"] | ["a", "889"] | ["a", "890"] | ["a", "891"] | ["a", "892"] | ["a", "893"] | ["a", "894"] | ["a", "895"] | ["a", "896"] | ["a", "897"] | ["a", "898"] | ["a", "899"] | ["a", "900"] | ["a", "901"] | ["a", "902"] | ["a", "903"] | ["a", "904"] | ["a", "905"] | ["a", "906"] | ["a", "907"] | ["a", "908"] | ["a", "909"] | ["a", "910"] | ["a", "911"] | ["a", "912"] | ["a", "913"] | ["a", "914"] | ["a", "915"] | ["a", "916"] | ["a", "917"] | ["a", "918"] | ["a", "919"] | ["a", "920"] | ["a", "921"] | ["a", "922"] | ["a", "923"] | ["a", "924"] | ["a", "925"] | ["a", "926"] | ["a", "927"] | ["a", "928"] | ["a", "929"] | ["a", "930"] | ["a", "931"] | ["a", "932"] | ["a", "933"] | ["a", "934"] | ["a", "935"] | ["a", "936"] | ["a", "937"] | ["a", "938"] | ["a", "939"] | ["a", "940"] | ["a", "941"] | ["a", "942"] | ["a", "943"] | ["a", "944"] | ["a", "945"] | ["a", "946"] | ["a", "947"] | ["a", "948"] | ["a", "949"] | ["a", "950"] | ["a", "951"] | ["a", "952"] | ["a", "953"] | ["a", "954"] | ["a", "955"] | ["a", "956"] | ["a", "957"] | ["a", "958"] | ["a", "959"] | ["a", "960"] | ["a", "961"] | ["a", "962"] | ["a", "963"] | ["a", "964"] | ["a", "965"] | ["a", "966"] | ["a", "967"] | ["a", "968"] | ["a", "969"] | ["a", "970"] | ["a", "971"] | ["a", "972"] | ["a", "973"] | ["a", "974"] | ["a", "975"] | ["a", "976"] | ["a", "977"] | ["a", "978"] | ["a", "979"] | ["a", "980"] | ["a", "981"] | ["a", "982"] | ["a", "983"] | ["a", "984"] | ["a", "985"] | ["a", "986"] | ["a", "987"] | ["a", "988"] | ["a", "989"] | ["a", "990"] | ["a", "991"] | ["a", "992"] | ["a", "993"] | ["a", "994"] | ["a", "995"] | ["a", "996"] | ["a", "997"] | ["a", "998"] | ["a", "999"] + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..9da9a188af742 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,17 @@ +instantiationCountSharedCheckOrder.ts(10,12): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== instantiationCountSharedCheckOrder.ts (1 errors) ==== + // Instantiating Wide<[], "a"> fresh takes over five million instantiations, + // which is too many. In program order Rest has already done all but about + // two million of them. Whether All takes too many must not depend on which + // comes first. + + type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + type K = `${D}${D}${D}`; + type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; + type Rest = Wide<[0, 0], "a">; + type All = Wide<[], "a">; + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..e139f88dccad8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type K = `${D}${D}${D}`; +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) + +type Rest = Wide<[0, 0], "a">; +>Rest : Symbol(Rest, Decl(instantiationCountSharedCheckOrder.ts, 7, 115)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + +type All = Wide<[], "a">; +>All : Symbol(All, Decl(instantiationCountSharedCheckOrder.ts, 8, 30)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..4ed5f89ebfadd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : D + +type K = `${D}${D}${D}`; +>K : "000" | "001" | "002" | "003" | "004" | "005" | "006" | "007" | "008" | "009" | "010" | "011" | "012" | "013" | "014" | "015" | "016" | "017" | "018" | "019" | "020" | "021" | "022" | "023" | "024" | "025" | "026" | "027" | "028" | "029" | "030" | "031" | "032" | "033" | "034" | "035" | "036" | "037" | "038" | "039" | "040" | "041" | "042" | "043" | "044" | "045" | "046" | "047" | "048" | "049" | "050" | "051" | "052" | "053" | "054" | "055" | "056" | "057" | "058" | "059" | "060" | "061" | "062" | "063" | "064" | "065" | "066" | "067" | "068" | "069" | "070" | "071" | "072" | "073" | "074" | "075" | "076" | "077" | "078" | "079" | "080" | "081" | "082" | "083" | "084" | "085" | "086" | "087" | "088" | "089" | "090" | "091" | "092" | "093" | "094" | "095" | "096" | "097" | "098" | "099" | "100" | "101" | "102" | "103" | "104" | "105" | "106" | "107" | "108" | "109" | "110" | "111" | "112" | "113" | "114" | "115" | "116" | "117" | "118" | "119" | "120" | "121" | "122" | "123" | "124" | "125" | "126" | "127" | "128" | "129" | "130" | "131" | "132" | "133" | "134" | "135" | "136" | "137" | "138" | "139" | "140" | "141" | "142" | "143" | "144" | "145" | "146" | "147" | "148" | "149" | "150" | "151" | "152" | "153" | "154" | "155" | "156" | "157" | "158" | "159" | "160" | "161" | "162" | "163" | "164" | "165" | "166" | "167" | "168" | "169" | "170" | "171" | "172" | "173" | "174" | "175" | "176" | "177" | "178" | "179" | "180" | "181" | "182" | "183" | "184" | "185" | "186" | "187" | "188" | "189" | "190" | "191" | "192" | "193" | "194" | "195" | "196" | "197" | "198" | "199" | "200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299" | "300" | "301" | "302" | "303" | "304" | "305" | "306" | "307" | "308" | "309" | "310" | "311" | "312" | "313" | "314" | "315" | "316" | "317" | "318" | "319" | "320" | "321" | "322" | "323" | "324" | "325" | "326" | "327" | "328" | "329" | "330" | "331" | "332" | "333" | "334" | "335" | "336" | "337" | "338" | "339" | "340" | "341" | "342" | "343" | "344" | "345" | "346" | "347" | "348" | "349" | "350" | "351" | "352" | "353" | "354" | "355" | "356" | "357" | "358" | "359" | "360" | "361" | "362" | "363" | "364" | "365" | "366" | "367" | "368" | "369" | "370" | "371" | "372" | "373" | "374" | "375" | "376" | "377" | "378" | "379" | "380" | "381" | "382" | "383" | "384" | "385" | "386" | "387" | "388" | "389" | "390" | "391" | "392" | "393" | "394" | "395" | "396" | "397" | "398" | "399" | "400" | "401" | "402" | "403" | "404" | "405" | "406" | "407" | "408" | "409" | "410" | "411" | "412" | "413" | "414" | "415" | "416" | "417" | "418" | "419" | "420" | "421" | "422" | "423" | "424" | "425" | "426" | "427" | "428" | "429" | "430" | "431" | "432" | "433" | "434" | "435" | "436" | "437" | "438" | "439" | "440" | "441" | "442" | "443" | "444" | "445" | "446" | "447" | "448" | "449" | "450" | "451" | "452" | "453" | "454" | "455" | "456" | "457" | "458" | "459" | "460" | "461" | "462" | "463" | "464" | "465" | "466" | "467" | "468" | "469" | "470" | "471" | "472" | "473" | "474" | "475" | "476" | "477" | "478" | "479" | "480" | "481" | "482" | "483" | "484" | "485" | "486" | "487" | "488" | "489" | "490" | "491" | "492" | "493" | "494" | "495" | "496" | "497" | "498" | "499" | "500" | "501" | "502" | "503" | "504" | "505" | "506" | "507" | "508" | "509" | "510" | "511" | "512" | "513" | "514" | "515" | "516" | "517" | "518" | "519" | "520" | "521" | "522" | "523" | "524" | "525" | "526" | "527" | "528" | "529" | "530" | "531" | "532" | "533" | "534" | "535" | "536" | "537" | "538" | "539" | "540" | "541" | "542" | "543" | "544" | "545" | "546" | "547" | "548" | "549" | "550" | "551" | "552" | "553" | "554" | "555" | "556" | "557" | "558" | "559" | "560" | "561" | "562" | "563" | "564" | "565" | "566" | "567" | "568" | "569" | "570" | "571" | "572" | "573" | "574" | "575" | "576" | "577" | "578" | "579" | "580" | "581" | "582" | "583" | "584" | "585" | "586" | "587" | "588" | "589" | "590" | "591" | "592" | "593" | "594" | "595" | "596" | "597" | "598" | "599" | "600" | "601" | "602" | "603" | "604" | "605" | "606" | "607" | "608" | "609" | "610" | "611" | "612" | "613" | "614" | "615" | "616" | "617" | "618" | "619" | "620" | "621" | "622" | "623" | "624" | "625" | "626" | "627" | "628" | "629" | "630" | "631" | "632" | "633" | "634" | "635" | "636" | "637" | "638" | "639" | "640" | "641" | "642" | "643" | "644" | "645" | "646" | "647" | "648" | "649" | "650" | "651" | "652" | "653" | "654" | "655" | "656" | "657" | "658" | "659" | "660" | "661" | "662" | "663" | "664" | "665" | "666" | "667" | "668" | "669" | "670" | "671" | "672" | "673" | "674" | "675" | "676" | "677" | "678" | "679" | "680" | "681" | "682" | "683" | "684" | "685" | "686" | "687" | "688" | "689" | "690" | "691" | "692" | "693" | "694" | "695" | "696" | "697" | "698" | "699" | "700" | "701" | "702" | "703" | "704" | "705" | "706" | "707" | "708" | "709" | "710" | "711" | "712" | "713" | "714" | "715" | "716" | "717" | "718" | "719" | "720" | "721" | "722" | "723" | "724" | "725" | "726" | "727" | "728" | "729" | "730" | "731" | "732" | "733" | "734" | "735" | "736" | "737" | "738" | "739" | "740" | "741" | "742" | "743" | "744" | "745" | "746" | "747" | "748" | "749" | "750" | "751" | "752" | "753" | "754" | "755" | "756" | "757" | "758" | "759" | "760" | "761" | "762" | "763" | "764" | "765" | "766" | "767" | "768" | "769" | "770" | "771" | "772" | "773" | "774" | "775" | "776" | "777" | "778" | "779" | "780" | "781" | "782" | "783" | "784" | "785" | "786" | "787" | "788" | "789" | "790" | "791" | "792" | "793" | "794" | "795" | "796" | "797" | "798" | "799" | "800" | "801" | "802" | "803" | "804" | "805" | "806" | "807" | "808" | "809" | "810" | "811" | "812" | "813" | "814" | "815" | "816" | "817" | "818" | "819" | "820" | "821" | "822" | "823" | "824" | "825" | "826" | "827" | "828" | "829" | "830" | "831" | "832" | "833" | "834" | "835" | "836" | "837" | "838" | "839" | "840" | "841" | "842" | "843" | "844" | "845" | "846" | "847" | "848" | "849" | "850" | "851" | "852" | "853" | "854" | "855" | "856" | "857" | "858" | "859" | "860" | "861" | "862" | "863" | "864" | "865" | "866" | "867" | "868" | "869" | "870" | "871" | "872" | "873" | "874" | "875" | "876" | "877" | "878" | "879" | "880" | "881" | "882" | "883" | "884" | "885" | "886" | "887" | "888" | "889" | "890" | "891" | "892" | "893" | "894" | "895" | "896" | "897" | "898" | "899" | "900" | "901" | "902" | "903" | "904" | "905" | "906" | "907" | "908" | "909" | "910" | "911" | "912" | "913" | "914" | "915" | "916" | "917" | "918" | "919" | "920" | "921" | "922" | "923" | "924" | "925" | "926" | "927" | "928" | "929" | "930" | "931" | "932" | "933" | "934" | "935" | "936" | "937" | "938" | "939" | "940" | "941" | "942" | "943" | "944" | "945" | "946" | "947" | "948" | "949" | "950" | "951" | "952" | "953" | "954" | "955" | "956" | "957" | "958" | "959" | "960" | "961" | "962" | "963" | "964" | "965" | "966" | "967" | "968" | "969" | "970" | "971" | "972" | "973" | "974" | "975" | "976" | "977" | "978" | "979" | "980" | "981" | "982" | "983" | "984" | "985" | "986" | "987" | "988" | "989" | "990" | "991" | "992" | "993" | "994" | "995" | "996" | "997" | "998" | "999" + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Wide + +type Rest = Wide<[0, 0], "a">; +>Rest : ["a", "000"] | ["a", "001"] | ["a", "002"] | ["a", "003"] | ["a", "004"] | ["a", "005"] | ["a", "006"] | ["a", "007"] | ["a", "008"] | ["a", "009"] | ["a", "010"] | ["a", "011"] | ["a", "012"] | ["a", "013"] | ["a", "014"] | ["a", "015"] | ["a", "016"] | ["a", "017"] | ["a", "018"] | ["a", "019"] | ["a", "020"] | ["a", "021"] | ["a", "022"] | ["a", "023"] | ["a", "024"] | ["a", "025"] | ["a", "026"] | ["a", "027"] | ["a", "028"] | ["a", "029"] | ["a", "030"] | ["a", "031"] | ["a", "032"] | ["a", "033"] | ["a", "034"] | ["a", "035"] | ["a", "036"] | ["a", "037"] | ["a", "038"] | ["a", "039"] | ["a", "040"] | ["a", "041"] | ["a", "042"] | ["a", "043"] | ["a", "044"] | ["a", "045"] | ["a", "046"] | ["a", "047"] | ["a", "048"] | ["a", "049"] | ["a", "050"] | ["a", "051"] | ["a", "052"] | ["a", "053"] | ["a", "054"] | ["a", "055"] | ["a", "056"] | ["a", "057"] | ["a", "058"] | ["a", "059"] | ["a", "060"] | ["a", "061"] | ["a", "062"] | ["a", "063"] | ["a", "064"] | ["a", "065"] | ["a", "066"] | ["a", "067"] | ["a", "068"] | ["a", "069"] | ["a", "070"] | ["a", "071"] | ["a", "072"] | ["a", "073"] | ["a", "074"] | ["a", "075"] | ["a", "076"] | ["a", "077"] | ["a", "078"] | ["a", "079"] | ["a", "080"] | ["a", "081"] | ["a", "082"] | ["a", "083"] | ["a", "084"] | ["a", "085"] | ["a", "086"] | ["a", "087"] | ["a", "088"] | ["a", "089"] | ["a", "090"] | ["a", "091"] | ["a", "092"] | ["a", "093"] | ["a", "094"] | ["a", "095"] | ["a", "096"] | ["a", "097"] | ["a", "098"] | ["a", "099"] | ["a", "100"] | ["a", "101"] | ["a", "102"] | ["a", "103"] | ["a", "104"] | ["a", "105"] | ["a", "106"] | ["a", "107"] | ["a", "108"] | ["a", "109"] | ["a", "110"] | ["a", "111"] | ["a", "112"] | ["a", "113"] | ["a", "114"] | ["a", "115"] | ["a", "116"] | ["a", "117"] | ["a", "118"] | ["a", "119"] | ["a", "120"] | ["a", "121"] | ["a", "122"] | ["a", "123"] | ["a", "124"] | ["a", "125"] | ["a", "126"] | ["a", "127"] | ["a", "128"] | ["a", "129"] | ["a", "130"] | ["a", "131"] | ["a", "132"] | ["a", "133"] | ["a", "134"] | ["a", "135"] | ["a", "136"] | ["a", "137"] | ["a", "138"] | ["a", "139"] | ["a", "140"] | ["a", "141"] | ["a", "142"] | ["a", "143"] | ["a", "144"] | ["a", "145"] | ["a", "146"] | ["a", "147"] | ["a", "148"] | ["a", "149"] | ["a", "150"] | ["a", "151"] | ["a", "152"] | ["a", "153"] | ["a", "154"] | ["a", "155"] | ["a", "156"] | ["a", "157"] | ["a", "158"] | ["a", "159"] | ["a", "160"] | ["a", "161"] | ["a", "162"] | ["a", "163"] | ["a", "164"] | ["a", "165"] | ["a", "166"] | ["a", "167"] | ["a", "168"] | ["a", "169"] | ["a", "170"] | ["a", "171"] | ["a", "172"] | ["a", "173"] | ["a", "174"] | ["a", "175"] | ["a", "176"] | ["a", "177"] | ["a", "178"] | ["a", "179"] | ["a", "180"] | ["a", "181"] | ["a", "182"] | ["a", "183"] | ["a", "184"] | ["a", "185"] | ["a", "186"] | ["a", "187"] | ["a", "188"] | ["a", "189"] | ["a", "190"] | ["a", "191"] | ["a", "192"] | ["a", "193"] | ["a", "194"] | ["a", "195"] | ["a", "196"] | ["a", "197"] | ["a", "198"] | ["a", "199"] | ["a", "200"] | ["a", "201"] | ["a", "202"] | ["a", "203"] | ["a", "204"] | ["a", "205"] | ["a", "206"] | ["a", "207"] | ["a", "208"] | ["a", "209"] | ["a", "210"] | ["a", "211"] | ["a", "212"] | ["a", "213"] | ["a", "214"] | ["a", "215"] | ["a", "216"] | ["a", "217"] | ["a", "218"] | ["a", "219"] | ["a", "220"] | ["a", "221"] | ["a", "222"] | ["a", "223"] | ["a", "224"] | ["a", "225"] | ["a", "226"] | ["a", "227"] | ["a", "228"] | ["a", "229"] | ["a", "230"] | ["a", "231"] | ["a", "232"] | ["a", "233"] | ["a", "234"] | ["a", "235"] | ["a", "236"] | ["a", "237"] | ["a", "238"] | ["a", "239"] | ["a", "240"] | ["a", "241"] | ["a", "242"] | ["a", "243"] | ["a", "244"] | ["a", "245"] | ["a", "246"] | ["a", "247"] | ["a", "248"] | ["a", "249"] | ["a", "250"] | ["a", "251"] | ["a", "252"] | ["a", "253"] | ["a", "254"] | ["a", "255"] | ["a", "256"] | ["a", "257"] | ["a", "258"] | ["a", "259"] | ["a", "260"] | ["a", "261"] | ["a", "262"] | ["a", "263"] | ["a", "264"] | ["a", "265"] | ["a", "266"] | ["a", "267"] | ["a", "268"] | ["a", "269"] | ["a", "270"] | ["a", "271"] | ["a", "272"] | ["a", "273"] | ["a", "274"] | ["a", "275"] | ["a", "276"] | ["a", "277"] | ["a", "278"] | ["a", "279"] | ["a", "280"] | ["a", "281"] | ["a", "282"] | ["a", "283"] | ["a", "284"] | ["a", "285"] | ["a", "286"] | ["a", "287"] | ["a", "288"] | ["a", "289"] | ["a", "290"] | ["a", "291"] | ["a", "292"] | ["a", "293"] | ["a", "294"] | ["a", "295"] | ["a", "296"] | ["a", "297"] | ["a", "298"] | ["a", "299"] | ["a", "300"] | ["a", "301"] | ["a", "302"] | ["a", "303"] | ["a", "304"] | ["a", "305"] | ["a", "306"] | ["a", "307"] | ["a", "308"] | ["a", "309"] | ["a", "310"] | ["a", "311"] | ["a", "312"] | ["a", "313"] | ["a", "314"] | ["a", "315"] | ["a", "316"] | ["a", "317"] | ["a", "318"] | ["a", "319"] | ["a", "320"] | ["a", "321"] | ["a", "322"] | ["a", "323"] | ["a", "324"] | ["a", "325"] | ["a", "326"] | ["a", "327"] | ["a", "328"] | ["a", "329"] | ["a", "330"] | ["a", "331"] | ["a", "332"] | ["a", "333"] | ["a", "334"] | ["a", "335"] | ["a", "336"] | ["a", "337"] | ["a", "338"] | ["a", "339"] | ["a", "340"] | ["a", "341"] | ["a", "342"] | ["a", "343"] | ["a", "344"] | ["a", "345"] | ["a", "346"] | ["a", "347"] | ["a", "348"] | ["a", "349"] | ["a", "350"] | ["a", "351"] | ["a", "352"] | ["a", "353"] | ["a", "354"] | ["a", "355"] | ["a", "356"] | ["a", "357"] | ["a", "358"] | ["a", "359"] | ["a", "360"] | ["a", "361"] | ["a", "362"] | ["a", "363"] | ["a", "364"] | ["a", "365"] | ["a", "366"] | ["a", "367"] | ["a", "368"] | ["a", "369"] | ["a", "370"] | ["a", "371"] | ["a", "372"] | ["a", "373"] | ["a", "374"] | ["a", "375"] | ["a", "376"] | ["a", "377"] | ["a", "378"] | ["a", "379"] | ["a", "380"] | ["a", "381"] | ["a", "382"] | ["a", "383"] | ["a", "384"] | ["a", "385"] | ["a", "386"] | ["a", "387"] | ["a", "388"] | ["a", "389"] | ["a", "390"] | ["a", "391"] | ["a", "392"] | ["a", "393"] | ["a", "394"] | ["a", "395"] | ["a", "396"] | ["a", "397"] | ["a", "398"] | ["a", "399"] | ["a", "400"] | ["a", "401"] | ["a", "402"] | ["a", "403"] | ["a", "404"] | ["a", "405"] | ["a", "406"] | ["a", "407"] | ["a", "408"] | ["a", "409"] | ["a", "410"] | ["a", "411"] | ["a", "412"] | ["a", "413"] | ["a", "414"] | ["a", "415"] | ["a", "416"] | ["a", "417"] | ["a", "418"] | ["a", "419"] | ["a", "420"] | ["a", "421"] | ["a", "422"] | ["a", "423"] | ["a", "424"] | ["a", "425"] | ["a", "426"] | ["a", "427"] | ["a", "428"] | ["a", "429"] | ["a", "430"] | ["a", "431"] | ["a", "432"] | ["a", "433"] | ["a", "434"] | ["a", "435"] | ["a", "436"] | ["a", "437"] | ["a", "438"] | ["a", "439"] | ["a", "440"] | ["a", "441"] | ["a", "442"] | ["a", "443"] | ["a", "444"] | ["a", "445"] | ["a", "446"] | ["a", "447"] | ["a", "448"] | ["a", "449"] | ["a", "450"] | ["a", "451"] | ["a", "452"] | ["a", "453"] | ["a", "454"] | ["a", "455"] | ["a", "456"] | ["a", "457"] | ["a", "458"] | ["a", "459"] | ["a", "460"] | ["a", "461"] | ["a", "462"] | ["a", "463"] | ["a", "464"] | ["a", "465"] | ["a", "466"] | ["a", "467"] | ["a", "468"] | ["a", "469"] | ["a", "470"] | ["a", "471"] | ["a", "472"] | ["a", "473"] | ["a", "474"] | ["a", "475"] | ["a", "476"] | ["a", "477"] | ["a", "478"] | ["a", "479"] | ["a", "480"] | ["a", "481"] | ["a", "482"] | ["a", "483"] | ["a", "484"] | ["a", "485"] | ["a", "486"] | ["a", "487"] | ["a", "488"] | ["a", "489"] | ["a", "490"] | ["a", "491"] | ["a", "492"] | ["a", "493"] | ["a", "494"] | ["a", "495"] | ["a", "496"] | ["a", "497"] | ["a", "498"] | ["a", "499"] | ["a", "500"] | ["a", "501"] | ["a", "502"] | ["a", "503"] | ["a", "504"] | ["a", "505"] | ["a", "506"] | ["a", "507"] | ["a", "508"] | ["a", "509"] | ["a", "510"] | ["a", "511"] | ["a", "512"] | ["a", "513"] | ["a", "514"] | ["a", "515"] | ["a", "516"] | ["a", "517"] | ["a", "518"] | ["a", "519"] | ["a", "520"] | ["a", "521"] | ["a", "522"] | ["a", "523"] | ["a", "524"] | ["a", "525"] | ["a", "526"] | ["a", "527"] | ["a", "528"] | ["a", "529"] | ["a", "530"] | ["a", "531"] | ["a", "532"] | ["a", "533"] | ["a", "534"] | ["a", "535"] | ["a", "536"] | ["a", "537"] | ["a", "538"] | ["a", "539"] | ["a", "540"] | ["a", "541"] | ["a", "542"] | ["a", "543"] | ["a", "544"] | ["a", "545"] | ["a", "546"] | ["a", "547"] | ["a", "548"] | ["a", "549"] | ["a", "550"] | ["a", "551"] | ["a", "552"] | ["a", "553"] | ["a", "554"] | ["a", "555"] | ["a", "556"] | ["a", "557"] | ["a", "558"] | ["a", "559"] | ["a", "560"] | ["a", "561"] | ["a", "562"] | ["a", "563"] | ["a", "564"] | ["a", "565"] | ["a", "566"] | ["a", "567"] | ["a", "568"] | ["a", "569"] | ["a", "570"] | ["a", "571"] | ["a", "572"] | ["a", "573"] | ["a", "574"] | ["a", "575"] | ["a", "576"] | ["a", "577"] | ["a", "578"] | ["a", "579"] | ["a", "580"] | ["a", "581"] | ["a", "582"] | ["a", "583"] | ["a", "584"] | ["a", "585"] | ["a", "586"] | ["a", "587"] | ["a", "588"] | ["a", "589"] | ["a", "590"] | ["a", "591"] | ["a", "592"] | ["a", "593"] | ["a", "594"] | ["a", "595"] | ["a", "596"] | ["a", "597"] | ["a", "598"] | ["a", "599"] | ["a", "600"] | ["a", "601"] | ["a", "602"] | ["a", "603"] | ["a", "604"] | ["a", "605"] | ["a", "606"] | ["a", "607"] | ["a", "608"] | ["a", "609"] | ["a", "610"] | ["a", "611"] | ["a", "612"] | ["a", "613"] | ["a", "614"] | ["a", "615"] | ["a", "616"] | ["a", "617"] | ["a", "618"] | ["a", "619"] | ["a", "620"] | ["a", "621"] | ["a", "622"] | ["a", "623"] | ["a", "624"] | ["a", "625"] | ["a", "626"] | ["a", "627"] | ["a", "628"] | ["a", "629"] | ["a", "630"] | ["a", "631"] | ["a", "632"] | ["a", "633"] | ["a", "634"] | ["a", "635"] | ["a", "636"] | ["a", "637"] | ["a", "638"] | ["a", "639"] | ["a", "640"] | ["a", "641"] | ["a", "642"] | ["a", "643"] | ["a", "644"] | ["a", "645"] | ["a", "646"] | ["a", "647"] | ["a", "648"] | ["a", "649"] | ["a", "650"] | ["a", "651"] | ["a", "652"] | ["a", "653"] | ["a", "654"] | ["a", "655"] | ["a", "656"] | ["a", "657"] | ["a", "658"] | ["a", "659"] | ["a", "660"] | ["a", "661"] | ["a", "662"] | ["a", "663"] | ["a", "664"] | ["a", "665"] | ["a", "666"] | ["a", "667"] | ["a", "668"] | ["a", "669"] | ["a", "670"] | ["a", "671"] | ["a", "672"] | ["a", "673"] | ["a", "674"] | ["a", "675"] | ["a", "676"] | ["a", "677"] | ["a", "678"] | ["a", "679"] | ["a", "680"] | ["a", "681"] | ["a", "682"] | ["a", "683"] | ["a", "684"] | ["a", "685"] | ["a", "686"] | ["a", "687"] | ["a", "688"] | ["a", "689"] | ["a", "690"] | ["a", "691"] | ["a", "692"] | ["a", "693"] | ["a", "694"] | ["a", "695"] | ["a", "696"] | ["a", "697"] | ["a", "698"] | ["a", "699"] | ["a", "700"] | ["a", "701"] | ["a", "702"] | ["a", "703"] | ["a", "704"] | ["a", "705"] | ["a", "706"] | ["a", "707"] | ["a", "708"] | ["a", "709"] | ["a", "710"] | ["a", "711"] | ["a", "712"] | ["a", "713"] | ["a", "714"] | ["a", "715"] | ["a", "716"] | ["a", "717"] | ["a", "718"] | ["a", "719"] | ["a", "720"] | ["a", "721"] | ["a", "722"] | ["a", "723"] | ["a", "724"] | ["a", "725"] | ["a", "726"] | ["a", "727"] | ["a", "728"] | ["a", "729"] | ["a", "730"] | ["a", "731"] | ["a", "732"] | ["a", "733"] | ["a", "734"] | ["a", "735"] | ["a", "736"] | ["a", "737"] | ["a", "738"] | ["a", "739"] | ["a", "740"] | ["a", "741"] | ["a", "742"] | ["a", "743"] | ["a", "744"] | ["a", "745"] | ["a", "746"] | ["a", "747"] | ["a", "748"] | ["a", "749"] | ["a", "750"] | ["a", "751"] | ["a", "752"] | ["a", "753"] | ["a", "754"] | ["a", "755"] | ["a", "756"] | ["a", "757"] | ["a", "758"] | ["a", "759"] | ["a", "760"] | ["a", "761"] | ["a", "762"] | ["a", "763"] | ["a", "764"] | ["a", "765"] | ["a", "766"] | ["a", "767"] | ["a", "768"] | ["a", "769"] | ["a", "770"] | ["a", "771"] | ["a", "772"] | ["a", "773"] | ["a", "774"] | ["a", "775"] | ["a", "776"] | ["a", "777"] | ["a", "778"] | ["a", "779"] | ["a", "780"] | ["a", "781"] | ["a", "782"] | ["a", "783"] | ["a", "784"] | ["a", "785"] | ["a", "786"] | ["a", "787"] | ["a", "788"] | ["a", "789"] | ["a", "790"] | ["a", "791"] | ["a", "792"] | ["a", "793"] | ["a", "794"] | ["a", "795"] | ["a", "796"] | ["a", "797"] | ["a", "798"] | ["a", "799"] | ["a", "800"] | ["a", "801"] | ["a", "802"] | ["a", "803"] | ["a", "804"] | ["a", "805"] | ["a", "806"] | ["a", "807"] | ["a", "808"] | ["a", "809"] | ["a", "810"] | ["a", "811"] | ["a", "812"] | ["a", "813"] | ["a", "814"] | ["a", "815"] | ["a", "816"] | ["a", "817"] | ["a", "818"] | ["a", "819"] | ["a", "820"] | ["a", "821"] | ["a", "822"] | ["a", "823"] | ["a", "824"] | ["a", "825"] | ["a", "826"] | ["a", "827"] | ["a", "828"] | ["a", "829"] | ["a", "830"] | ["a", "831"] | ["a", "832"] | ["a", "833"] | ["a", "834"] | ["a", "835"] | ["a", "836"] | ["a", "837"] | ["a", "838"] | ["a", "839"] | ["a", "840"] | ["a", "841"] | ["a", "842"] | ["a", "843"] | ["a", "844"] | ["a", "845"] | ["a", "846"] | ["a", "847"] | ["a", "848"] | ["a", "849"] | ["a", "850"] | ["a", "851"] | ["a", "852"] | ["a", "853"] | ["a", "854"] | ["a", "855"] | ["a", "856"] | ["a", "857"] | ["a", "858"] | ["a", "859"] | ["a", "860"] | ["a", "861"] | ["a", "862"] | ["a", "863"] | ["a", "864"] | ["a", "865"] | ["a", "866"] | ["a", "867"] | ["a", "868"] | ["a", "869"] | ["a", "870"] | ["a", "871"] | ["a", "872"] | ["a", "873"] | ["a", "874"] | ["a", "875"] | ["a", "876"] | ["a", "877"] | ["a", "878"] | ["a", "879"] | ["a", "880"] | ["a", "881"] | ["a", "882"] | ["a", "883"] | ["a", "884"] | ["a", "885"] | ["a", "886"] | ["a", "887"] | ["a", "888"] | ["a", "889"] | ["a", "890"] | ["a", "891"] | ["a", "892"] | ["a", "893"] | ["a", "894"] | ["a", "895"] | ["a", "896"] | ["a", "897"] | ["a", "898"] | ["a", "899"] | ["a", "900"] | ["a", "901"] | ["a", "902"] | ["a", "903"] | ["a", "904"] | ["a", "905"] | ["a", "906"] | ["a", "907"] | ["a", "908"] | ["a", "909"] | ["a", "910"] | ["a", "911"] | ["a", "912"] | ["a", "913"] | ["a", "914"] | ["a", "915"] | ["a", "916"] | ["a", "917"] | ["a", "918"] | ["a", "919"] | ["a", "920"] | ["a", "921"] | ["a", "922"] | ["a", "923"] | ["a", "924"] | ["a", "925"] | ["a", "926"] | ["a", "927"] | ["a", "928"] | ["a", "929"] | ["a", "930"] | ["a", "931"] | ["a", "932"] | ["a", "933"] | ["a", "934"] | ["a", "935"] | ["a", "936"] | ["a", "937"] | ["a", "938"] | ["a", "939"] | ["a", "940"] | ["a", "941"] | ["a", "942"] | ["a", "943"] | ["a", "944"] | ["a", "945"] | ["a", "946"] | ["a", "947"] | ["a", "948"] | ["a", "949"] | ["a", "950"] | ["a", "951"] | ["a", "952"] | ["a", "953"] | ["a", "954"] | ["a", "955"] | ["a", "956"] | ["a", "957"] | ["a", "958"] | ["a", "959"] | ["a", "960"] | ["a", "961"] | ["a", "962"] | ["a", "963"] | ["a", "964"] | ["a", "965"] | ["a", "966"] | ["a", "967"] | ["a", "968"] | ["a", "969"] | ["a", "970"] | ["a", "971"] | ["a", "972"] | ["a", "973"] | ["a", "974"] | ["a", "975"] | ["a", "976"] | ["a", "977"] | ["a", "978"] | ["a", "979"] | ["a", "980"] | ["a", "981"] | ["a", "982"] | ["a", "983"] | ["a", "984"] | ["a", "985"] | ["a", "986"] | ["a", "987"] | ["a", "988"] | ["a", "989"] | ["a", "990"] | ["a", "991"] | ["a", "992"] | ["a", "993"] | ["a", "994"] | ["a", "995"] | ["a", "996"] | ["a", "997"] | ["a", "998"] | ["a", "999"] + +type All = Wide<[], "a">; +>All : any + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..f884f93457e7e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : Symbol(Deep75, Decl(instantiationDepthSharedCheckOrder.ts, 5, 91)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : Symbol(Deep50, Decl(instantiationDepthSharedCheckOrder.ts, 6, 246)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : Symbol(Deep25, Decl(instantiationDepthSharedCheckOrder.ts, 7, 171)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type DeepAll = Deep<[]>; +>DeepAll : Symbol(DeepAll, Decl(instantiationDepthSharedCheckOrder.ts, 8, 96)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..19ec88f95d195 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Deep + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type DeepAll = Deep<[]>; +>DeepAll : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..f884f93457e7e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : Symbol(Deep75, Decl(instantiationDepthSharedCheckOrder.ts, 5, 91)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : Symbol(Deep50, Decl(instantiationDepthSharedCheckOrder.ts, 6, 246)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : Symbol(Deep25, Decl(instantiationDepthSharedCheckOrder.ts, 7, 171)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type DeepAll = Deep<[]>; +>DeepAll : Symbol(DeepAll, Decl(instantiationDepthSharedCheckOrder.ts, 8, 96)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..19ec88f95d195 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Deep + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type DeepAll = Deep<[]>; +>DeepAll : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..34b433cab41d3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,38 @@ +instantiationExpressionConstraintCycleCheckOrder.ts(10,25): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. +instantiationExpressionConstraintCycleCheckOrder.ts(17,41): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. + + +==== instantiationExpressionConstraintCycleCheckOrder.ts (2 errors) ==== + // Checking the type arguments of the instantiation expressions against their + // constraints needs the variances of A, which need the type of child. The + // constraint errors and the types of child must not depend on whether child + // is queried before A is checked. + + namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:8:17: This type parameter might need an `extends number` constraint. + } + } + + namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:15:13: This type parameter might need an `extends number` constraint. + static B = class B { + parent!: T; + }; + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..4f198380085a7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).js @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +//// [instantiationExpressionConstraintCycleCheckOrder.ts] +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + } +} + +namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + static B = class B { + parent!: T; + }; + } +} + + +//// [instantiationExpressionConstraintCycleCheckOrder.js] +"use strict"; +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. +var InterfaceCycle; +(function (InterfaceCycle) { +})(InterfaceCycle || (InterfaceCycle = {})); +var ClassCycle; +(function (ClassCycle) { + class A { + value; + child; + static B = class B { + parent; + }; + } +})(ClassCycle || (ClassCycle = {})); diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..8651ce4a98d10 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).symbols @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : Symbol(InterfaceCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 0, 0)) + + declare function b(): U; +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) + + interface A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + value: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 29)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + child: typeof b>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 8, 17)) +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + } +} + +namespace ClassCycle { +>ClassCycle : Symbol(ClassCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 11, 1)) + + class A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + value!: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 25)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + child!: InstanceType>>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 15, 18)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>A.B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + static B = class B { +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>B : Symbol(B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 18)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) + + parent!: T; +>parent : Symbol(B.parent, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 41)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..21ae95de09035 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).types @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : typeof InterfaceCycle + + declare function b(): U; +>b : >() => U + + interface A { + value: T; +>value : T + + child: typeof b>; +>child : typeof b> +>b : >() => U + } +} + +namespace ClassCycle { +>ClassCycle : typeof ClassCycle + + class A { +>A : A + + value!: T; +>value : T + + child!: InstanceType>>; +>child : B> +>A.B : typeof B +>A : typeof A +>B : typeof B + + static B = class B { +>B : typeof B +>class B { parent!: T; } : typeof B +>B : typeof B + + parent!: T; +>parent : T + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..34b433cab41d3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,38 @@ +instantiationExpressionConstraintCycleCheckOrder.ts(10,25): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. +instantiationExpressionConstraintCycleCheckOrder.ts(17,41): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. + + +==== instantiationExpressionConstraintCycleCheckOrder.ts (2 errors) ==== + // Checking the type arguments of the instantiation expressions against their + // constraints needs the variances of A, which need the type of child. The + // constraint errors and the types of child must not depend on whether child + // is queried before A is checked. + + namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:8:17: This type parameter might need an `extends number` constraint. + } + } + + namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:15:13: This type parameter might need an `extends number` constraint. + static B = class B { + parent!: T; + }; + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..4f198380085a7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +//// [instantiationExpressionConstraintCycleCheckOrder.ts] +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + } +} + +namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + static B = class B { + parent!: T; + }; + } +} + + +//// [instantiationExpressionConstraintCycleCheckOrder.js] +"use strict"; +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. +var InterfaceCycle; +(function (InterfaceCycle) { +})(InterfaceCycle || (InterfaceCycle = {})); +var ClassCycle; +(function (ClassCycle) { + class A { + value; + child; + static B = class B { + parent; + }; + } +})(ClassCycle || (ClassCycle = {})); diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..8651ce4a98d10 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : Symbol(InterfaceCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 0, 0)) + + declare function b(): U; +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) + + interface A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + value: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 29)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + child: typeof b>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 8, 17)) +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + } +} + +namespace ClassCycle { +>ClassCycle : Symbol(ClassCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 11, 1)) + + class A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + value!: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 25)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + child!: InstanceType>>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 15, 18)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>A.B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + static B = class B { +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>B : Symbol(B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 18)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) + + parent!: T; +>parent : Symbol(B.parent, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 41)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..21ae95de09035 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : typeof InterfaceCycle + + declare function b(): U; +>b : >() => U + + interface A { + value: T; +>value : T + + child: typeof b>; +>child : typeof b> +>b : >() => U + } +} + +namespace ClassCycle { +>ClassCycle : typeof ClassCycle + + class A { +>A : A + + value!: T; +>value : T + + child!: InstanceType>>; +>child : B> +>A.B : typeof B +>A : typeof A +>B : typeof B + + static B = class B { +>B : typeof B +>class B { parent!: T; } : typeof B +>B : typeof B + + parent!: T; +>parent : T + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.errors.txt new file mode 100644 index 0000000000000..069ae1cb033da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.errors.txt @@ -0,0 +1,21 @@ +instantiationExpressionConstraintInStaticClassExpression.ts(6,35): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. + + +==== instantiationExpressionConstraintInStaticClassExpression.ts (1 errors) ==== + // A does not satisfy the constraint A of B, as T is not assignable to + // number, which must be reported. + + class A { + value!: T; + child!: InstanceType>>; // this should error + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintInStaticClassExpression.ts:4:9: This type parameter might need an `extends number` constraint. + + static B = class B { + parent!: T; + }; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.symbols b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.symbols new file mode 100644 index 0000000000000..e7a7218e1a855 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.symbols @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts] //// + +=== instantiationExpressionConstraintInStaticClassExpression.ts === +// A does not satisfy the constraint A of B, as T is not assignable to +// number, which must be reported. + +class A { +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 8)) + + value!: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 21)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 8)) + + child!: InstanceType>>; // this should error +>child : Symbol(A.child, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 4, 12)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>A.B : Symbol(A.B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 5, 41)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>B : Symbol(A.B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 5, 41)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 8)) + + static B = class B { +>B : Symbol(A.B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 5, 41)) +>B : Symbol(B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 12)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 21)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) + + parent!: T; +>parent : Symbol(B.parent, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 39)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 21)) + + }; +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.types b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.types new file mode 100644 index 0000000000000..4f1d247f40a86 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts] //// + +=== instantiationExpressionConstraintInStaticClassExpression.ts === +// A does not satisfy the constraint A of B, as T is not assignable to +// number, which must be reported. + +class A { +>A : A + + value!: T; +>value : T + + child!: InstanceType>>; // this should error +>child : B> +>A.B : typeof B +>A : typeof A +>B : typeof B + + static B = class B { +>B : typeof B +>class B { parent!: T; } : typeof B +>B : typeof B + + parent!: T; +>parent : T + + }; +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt new file mode 100644 index 0000000000000..69dd6c2b622df --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt @@ -0,0 +1,24 @@ +instantiationLimitsCheckOrder.ts(11,16): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== instantiationLimitsCheckOrder.ts (1 errors) ==== + // The depth limit on instantiations must not depend on what was + // instantiated before. The limit on the number of instantiations does, as + // it only stops runaway instantiations, so it is only tested for a single + // statement whose work nothing else shares. + + type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + type K = `${D}${D}${D}`; + + // Several million instantiations, well over the limit, for one statement. + type Wide = N["length"] extends 8 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K]; + type WideAll = Wide<[], "">; + ~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // Over a hundred nested instantiations, half of which already happened for + // another statement. + type Deep = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"]; + type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + type DeepAll = Deep<[]>; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols new file mode 100644 index 0000000000000..c49f0e567e06e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/instantiationLimitsCheckOrder.ts] //// + +=== instantiationLimitsCheckOrder.ts === +// The depth limit on instantiations must not depend on what was +// instantiated before. The limit on the number of instantiations does, as +// it only stops runaway instantiations, so it is only tested for a single +// statement whose work nothing else shares. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) + +type K = `${D}${D}${D}`; +>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47)) +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) + +// Several million instantiations, well over the limit, for one statement. +type Wide = N["length"] extends 8 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K]; +>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10)) +>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10)) +>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24)) +>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 9, 61)) +>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47)) +>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10)) +>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 9, 61)) +>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24)) +>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47)) + +type WideAll = Wide<[], "">; +>WideAll : Symbol(WideAll, Decl(instantiationLimitsCheckOrder.ts, 9, 102)) +>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24)) + +// Over a hundred nested instantiations, half of which already happened for +// another statement. +type Deep = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) + +type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>DeepTail : Symbol(DeepTail, Decl(instantiationLimitsCheckOrder.ts, 14, 90)) +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) + +type DeepAll = Deep<[]>; +>DeepAll : Symbol(DeepAll, Decl(instantiationLimitsCheckOrder.ts, 15, 113)) +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.types b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.types new file mode 100644 index 0000000000000..5227b6c530923 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.types @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/instantiationLimitsCheckOrder.ts] //// + +=== instantiationLimitsCheckOrder.ts === +// The depth limit on instantiations must not depend on what was +// instantiated before. The limit on the number of instantiations does, as +// it only stops runaway instantiations, so it is only tested for a single +// statement whose work nothing else shares. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : D + +type K = `${D}${D}${D}`; +>K : "000" | "001" | "002" | "003" | "004" | "005" | "006" | "007" | "008" | "009" | "010" | "011" | "012" | "013" | "014" | "015" | "016" | "017" | "018" | "019" | "020" | "021" | "022" | "023" | "024" | "025" | "026" | "027" | "028" | "029" | "030" | "031" | "032" | "033" | "034" | "035" | "036" | "037" | "038" | "039" | "040" | "041" | "042" | "043" | "044" | "045" | "046" | "047" | "048" | "049" | "050" | "051" | "052" | "053" | "054" | "055" | "056" | "057" | "058" | "059" | "060" | "061" | "062" | "063" | "064" | "065" | "066" | "067" | "068" | "069" | "070" | "071" | "072" | "073" | "074" | "075" | "076" | "077" | "078" | "079" | "080" | "081" | "082" | "083" | "084" | "085" | "086" | "087" | "088" | "089" | "090" | "091" | "092" | "093" | "094" | "095" | "096" | "097" | "098" | "099" | "100" | "101" | "102" | "103" | "104" | "105" | "106" | "107" | "108" | "109" | "110" | "111" | "112" | "113" | "114" | "115" | "116" | "117" | "118" | "119" | "120" | "121" | "122" | "123" | "124" | "125" | "126" | "127" | "128" | "129" | "130" | "131" | "132" | "133" | "134" | "135" | "136" | "137" | "138" | "139" | "140" | "141" | "142" | "143" | "144" | "145" | "146" | "147" | "148" | "149" | "150" | "151" | "152" | "153" | "154" | "155" | "156" | "157" | "158" | "159" | "160" | "161" | "162" | "163" | "164" | "165" | "166" | "167" | "168" | "169" | "170" | "171" | "172" | "173" | "174" | "175" | "176" | "177" | "178" | "179" | "180" | "181" | "182" | "183" | "184" | "185" | "186" | "187" | "188" | "189" | "190" | "191" | "192" | "193" | "194" | "195" | "196" | "197" | "198" | "199" | "200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299" | "300" | "301" | "302" | "303" | "304" | "305" | "306" | "307" | "308" | "309" | "310" | "311" | "312" | "313" | "314" | "315" | "316" | "317" | "318" | "319" | "320" | "321" | "322" | "323" | "324" | "325" | "326" | "327" | "328" | "329" | "330" | "331" | "332" | "333" | "334" | "335" | "336" | "337" | "338" | "339" | "340" | "341" | "342" | "343" | "344" | "345" | "346" | "347" | "348" | "349" | "350" | "351" | "352" | "353" | "354" | "355" | "356" | "357" | "358" | "359" | "360" | "361" | "362" | "363" | "364" | "365" | "366" | "367" | "368" | "369" | "370" | "371" | "372" | "373" | "374" | "375" | "376" | "377" | "378" | "379" | "380" | "381" | "382" | "383" | "384" | "385" | "386" | "387" | "388" | "389" | "390" | "391" | "392" | "393" | "394" | "395" | "396" | "397" | "398" | "399" | "400" | "401" | "402" | "403" | "404" | "405" | "406" | "407" | "408" | "409" | "410" | "411" | "412" | "413" | "414" | "415" | "416" | "417" | "418" | "419" | "420" | "421" | "422" | "423" | "424" | "425" | "426" | "427" | "428" | "429" | "430" | "431" | "432" | "433" | "434" | "435" | "436" | "437" | "438" | "439" | "440" | "441" | "442" | "443" | "444" | "445" | "446" | "447" | "448" | "449" | "450" | "451" | "452" | "453" | "454" | "455" | "456" | "457" | "458" | "459" | "460" | "461" | "462" | "463" | "464" | "465" | "466" | "467" | "468" | "469" | "470" | "471" | "472" | "473" | "474" | "475" | "476" | "477" | "478" | "479" | "480" | "481" | "482" | "483" | "484" | "485" | "486" | "487" | "488" | "489" | "490" | "491" | "492" | "493" | "494" | "495" | "496" | "497" | "498" | "499" | "500" | "501" | "502" | "503" | "504" | "505" | "506" | "507" | "508" | "509" | "510" | "511" | "512" | "513" | "514" | "515" | "516" | "517" | "518" | "519" | "520" | "521" | "522" | "523" | "524" | "525" | "526" | "527" | "528" | "529" | "530" | "531" | "532" | "533" | "534" | "535" | "536" | "537" | "538" | "539" | "540" | "541" | "542" | "543" | "544" | "545" | "546" | "547" | "548" | "549" | "550" | "551" | "552" | "553" | "554" | "555" | "556" | "557" | "558" | "559" | "560" | "561" | "562" | "563" | "564" | "565" | "566" | "567" | "568" | "569" | "570" | "571" | "572" | "573" | "574" | "575" | "576" | "577" | "578" | "579" | "580" | "581" | "582" | "583" | "584" | "585" | "586" | "587" | "588" | "589" | "590" | "591" | "592" | "593" | "594" | "595" | "596" | "597" | "598" | "599" | "600" | "601" | "602" | "603" | "604" | "605" | "606" | "607" | "608" | "609" | "610" | "611" | "612" | "613" | "614" | "615" | "616" | "617" | "618" | "619" | "620" | "621" | "622" | "623" | "624" | "625" | "626" | "627" | "628" | "629" | "630" | "631" | "632" | "633" | "634" | "635" | "636" | "637" | "638" | "639" | "640" | "641" | "642" | "643" | "644" | "645" | "646" | "647" | "648" | "649" | "650" | "651" | "652" | "653" | "654" | "655" | "656" | "657" | "658" | "659" | "660" | "661" | "662" | "663" | "664" | "665" | "666" | "667" | "668" | "669" | "670" | "671" | "672" | "673" | "674" | "675" | "676" | "677" | "678" | "679" | "680" | "681" | "682" | "683" | "684" | "685" | "686" | "687" | "688" | "689" | "690" | "691" | "692" | "693" | "694" | "695" | "696" | "697" | "698" | "699" | "700" | "701" | "702" | "703" | "704" | "705" | "706" | "707" | "708" | "709" | "710" | "711" | "712" | "713" | "714" | "715" | "716" | "717" | "718" | "719" | "720" | "721" | "722" | "723" | "724" | "725" | "726" | "727" | "728" | "729" | "730" | "731" | "732" | "733" | "734" | "735" | "736" | "737" | "738" | "739" | "740" | "741" | "742" | "743" | "744" | "745" | "746" | "747" | "748" | "749" | "750" | "751" | "752" | "753" | "754" | "755" | "756" | "757" | "758" | "759" | "760" | "761" | "762" | "763" | "764" | "765" | "766" | "767" | "768" | "769" | "770" | "771" | "772" | "773" | "774" | "775" | "776" | "777" | "778" | "779" | "780" | "781" | "782" | "783" | "784" | "785" | "786" | "787" | "788" | "789" | "790" | "791" | "792" | "793" | "794" | "795" | "796" | "797" | "798" | "799" | "800" | "801" | "802" | "803" | "804" | "805" | "806" | "807" | "808" | "809" | "810" | "811" | "812" | "813" | "814" | "815" | "816" | "817" | "818" | "819" | "820" | "821" | "822" | "823" | "824" | "825" | "826" | "827" | "828" | "829" | "830" | "831" | "832" | "833" | "834" | "835" | "836" | "837" | "838" | "839" | "840" | "841" | "842" | "843" | "844" | "845" | "846" | "847" | "848" | "849" | "850" | "851" | "852" | "853" | "854" | "855" | "856" | "857" | "858" | "859" | "860" | "861" | "862" | "863" | "864" | "865" | "866" | "867" | "868" | "869" | "870" | "871" | "872" | "873" | "874" | "875" | "876" | "877" | "878" | "879" | "880" | "881" | "882" | "883" | "884" | "885" | "886" | "887" | "888" | "889" | "890" | "891" | "892" | "893" | "894" | "895" | "896" | "897" | "898" | "899" | "900" | "901" | "902" | "903" | "904" | "905" | "906" | "907" | "908" | "909" | "910" | "911" | "912" | "913" | "914" | "915" | "916" | "917" | "918" | "919" | "920" | "921" | "922" | "923" | "924" | "925" | "926" | "927" | "928" | "929" | "930" | "931" | "932" | "933" | "934" | "935" | "936" | "937" | "938" | "939" | "940" | "941" | "942" | "943" | "944" | "945" | "946" | "947" | "948" | "949" | "950" | "951" | "952" | "953" | "954" | "955" | "956" | "957" | "958" | "959" | "960" | "961" | "962" | "963" | "964" | "965" | "966" | "967" | "968" | "969" | "970" | "971" | "972" | "973" | "974" | "975" | "976" | "977" | "978" | "979" | "980" | "981" | "982" | "983" | "984" | "985" | "986" | "987" | "988" | "989" | "990" | "991" | "992" | "993" | "994" | "995" | "996" | "997" | "998" | "999" + +// Several million instantiations, well over the limit, for one statement. +type Wide = N["length"] extends 8 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K]; +>Wide : Wide + +type WideAll = Wide<[], "">; +>WideAll : any + +// Over a hundred nested instantiations, half of which already happened for +// another statement. +type Deep = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Deep + +type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>DeepTail : 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 + +type DeepAll = Deep<[]>; +>DeepAll : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..0206551fbf855 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,27 @@ +instantiationStackLimitCheckOrder.ts(6,48): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(7,10): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(14,11): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== instantiationStackLimitCheckOrder.ts (3 errors) ==== + // F<[]> recurses forever, so instantiating it reaches the limit on the + // instantiation stack, wherever it is first instantiated. The instantiations + // in progress then fail as a whole, and none of them may be cached partly + // built for the other declaration to reuse. + + type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; + ~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + type X = F<[]>; + ~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // The element type of A[] is resolved whenever first needed, inside the + // instantiation of the return type of flat or not. Reaching the limit while + // flattening it must fail the same instantiations either way. + + type A = A[]; + const r = ([] as A).flat(Infinity); + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..97100f75a4cf2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) + +type X = F<[]>; +>X : Symbol(X, Decl(instantiationStackLimitCheckOrder.ts, 5, 65)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) + +const r = ([] as A).flat(Infinity); +>r : Symbol(r, Decl(instantiationStackLimitCheckOrder.ts, 13, 5)) +>([] as A).flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>Infinity : Symbol(Infinity, Decl(lib.es5.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..f9ab2f388174d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : F + +type X = F<[]>; +>X : any + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : A + +const r = ([] as A).flat(Infinity); +>r : any[] +>([] as A).flat(Infinity) : any[] +>([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] +>([] as A) : A +>[] as A : A +>[] : never[] +>flat : (this: A, depth?: D | undefined) => FlatArray[] +>Infinity : number + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..0206551fbf855 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,27 @@ +instantiationStackLimitCheckOrder.ts(6,48): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(7,10): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(14,11): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== instantiationStackLimitCheckOrder.ts (3 errors) ==== + // F<[]> recurses forever, so instantiating it reaches the limit on the + // instantiation stack, wherever it is first instantiated. The instantiations + // in progress then fail as a whole, and none of them may be cached partly + // built for the other declaration to reuse. + + type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; + ~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + type X = F<[]>; + ~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // The element type of A[] is resolved whenever first needed, inside the + // instantiation of the return type of flat or not. Reaching the limit while + // flattening it must fail the same instantiations either way. + + type A = A[]; + const r = ([] as A).flat(Infinity); + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..97100f75a4cf2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) + +type X = F<[]>; +>X : Symbol(X, Decl(instantiationStackLimitCheckOrder.ts, 5, 65)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) + +const r = ([] as A).flat(Infinity); +>r : Symbol(r, Decl(instantiationStackLimitCheckOrder.ts, 13, 5)) +>([] as A).flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>Infinity : Symbol(Infinity, Decl(lib.es5.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..f9ab2f388174d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : F + +type X = F<[]>; +>X : any + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : A + +const r = ([] as A).flat(Infinity); +>r : any[] +>([] as A).flat(Infinity) : any[] +>([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] +>([] as A) : A +>[] as A : A +>[] : never[] +>flat : (this: A, depth?: D | undefined) => FlatArray[] +>Infinity : number + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..999b86cd14552 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,16 @@ +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2310: Type 'C' recursively references itself as a base type. +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2506: 'C' is referenced directly or indirectly in its own base expression. + + +==== intersectionBaseConstructorCycleCheckOrder.ts (2 errors) ==== + // The type of x depends on the members of C, which depend on its base B, + // whose members depend on the type of x. Whichever is resolved first, the + // cycle must be resolved the same way. + + declare const B: (new (x: C["p"]) => {}) & (new () => {}); + declare class C extends B { p: number; } + ~ +!!! error TS2310: Type 'C' recursively references itself as a base type. + ~ +!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..1110d38181fac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +//// [intersectionBaseConstructorCycleCheckOrder.ts] +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +declare class C extends B { p: number; } + + +//// [intersectionBaseConstructorCycleCheckOrder.js] +"use strict"; +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3e614bc639b69 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).symbols @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>x : Symbol(x, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 23)) +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) + +declare class C extends B { p: number; } +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>p : Symbol(C.p, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 5, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..3a18ead789620 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : (new (x: C["p"]) => {}) & (new () => {}) +>x : number + +declare class C extends B { p: number; } +>C : C +>B : (new (x: C["p"]) => {}) & (new () => {}) +>p : number + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..999b86cd14552 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2310: Type 'C' recursively references itself as a base type. +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2506: 'C' is referenced directly or indirectly in its own base expression. + + +==== intersectionBaseConstructorCycleCheckOrder.ts (2 errors) ==== + // The type of x depends on the members of C, which depend on its base B, + // whose members depend on the type of x. Whichever is resolved first, the + // cycle must be resolved the same way. + + declare const B: (new (x: C["p"]) => {}) & (new () => {}); + declare class C extends B { p: number; } + ~ +!!! error TS2310: Type 'C' recursively references itself as a base type. + ~ +!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..1110d38181fac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +//// [intersectionBaseConstructorCycleCheckOrder.ts] +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +declare class C extends B { p: number; } + + +//// [intersectionBaseConstructorCycleCheckOrder.js] +"use strict"; +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3e614bc639b69 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>x : Symbol(x, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 23)) +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) + +declare class C extends B { p: number; } +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>p : Symbol(C.p, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 5, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..3a18ead789620 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : (new (x: C["p"]) => {}) & (new () => {}) +>x : number + +declare class C extends B { p: number; } +>C : C +>B : (new (x: C["p"]) => {}) & (new () => {}) +>p : number + diff --git a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt index 4687c6ca6a727..8f54167c9ef56 100644 --- a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt @@ -1,14 +1,11 @@ -a.ts(2,23): error TS2304: Cannot find name 'x'. a.ts(2,23): error TS2503: Cannot find namespace 'x'. a.ts(13,5): error TS2440: Import declaration conflicts with local declaration of 'A'. -==== a.ts (3 errors) ==== +==== a.ts (2 errors) ==== namespace a { export import A = x.A; ~ -!!! error TS2304: Cannot find name 'x'. - ~ !!! error TS2503: Cannot find namespace 'x'. export type A = number; } diff --git a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt index adf7becde9bb2..e4cc587d6a4c5 100644 --- a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt @@ -1,18 +1,15 @@ a.ts(1,11): error TS1280: Namespaces are not allowed in global script files when 'isolatedModules' is enabled. If this file is not intended to be a global script, set 'moduleDetection' to 'force' or add an empty 'export {}' statement. -a.ts(2,23): error TS2304: Cannot find name 'x'. a.ts(2,23): error TS2503: Cannot find namespace 'x'. a.ts(12,11): error TS1280: Namespaces are not allowed in global script files when 'isolatedModules' is enabled. If this file is not intended to be a global script, set 'moduleDetection' to 'force' or add an empty 'export {}' statement. a.ts(13,5): error TS2440: Import declaration conflicts with local declaration of 'A'. -==== a.ts (5 errors) ==== +==== a.ts (4 errors) ==== namespace a { ~ !!! error TS1280: Namespaces are not allowed in global script files when 'isolatedModules' is enabled. If this file is not intended to be a global script, set 'moduleDetection' to 'force' or add an empty 'export {}' statement. export import A = x.A; ~ -!!! error TS2304: Cannot find name 'x'. - ~ !!! error TS2503: Cannot find namespace 'x'. export type A = number; } diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt new file mode 100644 index 0000000000000..bafe2d1546822 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt @@ -0,0 +1,19 @@ +file.js(4,11): error TS7022: 'pixel' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +file.js(4,19): error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. +file.js(5,24): error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. + + +==== file.js (3 errors) ==== + /** @param {any} axis @param {any} value */ + function updateElements(axis, value) { + const properties = {}; + const pixel = properties[axis] = value; + ~~~~~ +!!! error TS7022: 'pixel' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~~~~~~~~~~~~~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. + const otherPixel = properties[axis] = value; + ~~~~~~~~~~~~~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. + properties.skip = isNaN(pixel) || isNaN(otherPixel); + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.js b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.js new file mode 100644 index 0000000000000..d660e1f2146fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts] //// + +//// [file.js] +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { + const properties = {}; + const pixel = properties[axis] = value; + const otherPixel = properties[axis] = value; + properties.skip = isNaN(pixel) || isNaN(otherPixel); +} + +//// [file.js] +"use strict"; +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { + const properties = {}; + const pixel = properties[axis] = value; + const otherPixel = properties[axis] = value; + properties.skip = isNaN(pixel) || isNaN(otherPixel); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.symbols b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.symbols new file mode 100644 index 0000000000000..373963a684ab3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts] //// + +=== file.js === +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { +>updateElements : Symbol(updateElements, Decl(file.js, 0, 0)) +>axis : Symbol(axis, Decl(file.js, 1, 24)) +>value : Symbol(value, Decl(file.js, 1, 29)) + + const properties = {}; +>properties : Symbol(properties, Decl(file.js, 2, 9)) + + const pixel = properties[axis] = value; +>pixel : Symbol(pixel, Decl(file.js, 3, 9)) +>properties : Symbol(properties, Decl(file.js, 2, 9)) +>axis : Symbol(axis, Decl(file.js, 1, 24)) +>value : Symbol(value, Decl(file.js, 1, 29)) + + const otherPixel = properties[axis] = value; +>otherPixel : Symbol(otherPixel, Decl(file.js, 4, 9)) +>properties : Symbol(properties, Decl(file.js, 2, 9)) +>axis : Symbol(axis, Decl(file.js, 1, 24)) +>value : Symbol(value, Decl(file.js, 1, 29)) + + properties.skip = isNaN(pixel) || isNaN(otherPixel); +>properties.skip : Symbol(skip, Decl(file.js, 4, 48)) +>properties : Symbol(properties, Decl(file.js, 2, 9)) +>skip : Symbol(skip, Decl(file.js, 4, 48)) +>isNaN : Symbol(isNaN, Decl(lib.es5.d.ts, --, --)) +>pixel : Symbol(pixel, Decl(file.js, 3, 9)) +>isNaN : Symbol(isNaN, Decl(lib.es5.d.ts, --, --)) +>otherPixel : Symbol(otherPixel, Decl(file.js, 4, 9)) +} diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.types b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.types new file mode 100644 index 0000000000000..607a8ed056027 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts] //// + +=== file.js === +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { +>updateElements : (axis: any, value: any) => void +>axis : any +>value : any + + const properties = {}; +>properties : { skip: any; } +>{} : { skip: any; } + + const pixel = properties[axis] = value; +>pixel : any +>properties[axis] = value : any +>properties[axis] : any +>properties : { skip: any; } +>axis : any +>value : any + + const otherPixel = properties[axis] = value; +>otherPixel : any +>properties[axis] = value : any +>properties[axis] : any +>properties : { skip: any; } +>axis : any +>value : any + + properties.skip = isNaN(pixel) || isNaN(otherPixel); +>properties.skip = isNaN(pixel) || isNaN(otherPixel) : boolean +>properties.skip : any +>properties : { skip: any; } +>skip : any +>isNaN(pixel) || isNaN(otherPixel) : boolean +>isNaN(pixel) : boolean +>isNaN : (number: number) => boolean +>pixel : any +>isNaN(otherPixel) : boolean +>isNaN : (number: number) => boolean +>otherPixel : any +} diff --git a/tsc/testdata/baselines/reference/compiler/jsFunctionWithPrototypeNoErrorTruncationNoCrash.types b/tsc/testdata/baselines/reference/compiler/jsFunctionWithPrototypeNoErrorTruncationNoCrash.types index 4a0539f482866..de17cf44aec12 100644 --- a/tsc/testdata/baselines/reference/compiler/jsFunctionWithPrototypeNoErrorTruncationNoCrash.types +++ b/tsc/testdata/baselines/reference/compiler/jsFunctionWithPrototypeNoErrorTruncationNoCrash.types @@ -2,7 +2,7 @@ === index.js === function Color(obj) { ->Color : { (obj: any): void; prototype: { negate: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; clearer: (ratio: any) => any; toJSON: () => any; }; } +>Color : { (obj: any): void; prototype: { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; } >obj : any this.example = true @@ -15,9 +15,9 @@ function Color(obj) { }; Color.prototype = { >Color.prototype = { negate: function () {return this;}, lighten: function (ratio) {return this;}, darken: function (ratio) {return this;}, saturate: function (ratio) {return this;}, desaturate: function (ratio) {return this;}, whiten: function (ratio) {return this;}, blacken: function (ratio) {return this;}, greyscale: function () {return this;}, clearer: function (ratio) {return this;}, toJSON: function () {return this.rgb();},} : { negate: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; clearer: (ratio: any) => any; toJSON: () => any; } ->Color.prototype : { negate: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; clearer: (ratio: any) => any; toJSON: () => any; } ->Color : { (obj: any): void; prototype: { negate: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; clearer: (ratio: any) => any; toJSON: () => any; }; } ->prototype : { negate: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; clearer: (ratio: any) => any; toJSON: () => any; } +>Color.prototype : { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; } +>Color : { (obj: any): void; prototype: { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; } +>prototype : { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; } >{ negate: function () {return this;}, lighten: function (ratio) {return this;}, darken: function (ratio) {return this;}, saturate: function (ratio) {return this;}, desaturate: function (ratio) {return this;}, whiten: function (ratio) {return this;}, blacken: function (ratio) {return this;}, greyscale: function () {return this;}, clearer: function (ratio) {return this;}, toJSON: function () {return this.rgb();},} : { negate: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => { negate: () => any; lighten: (ratio: any) => any; darken: (ratio: any) => any; saturate: (ratio: any) => any; desaturate: (ratio: any) => any; whiten: (ratio: any) => any; blacken: (ratio: any) => any; greyscale: () => any; clearer: (ratio: any) => any; toJSON: () => any; }; clearer: (ratio: any) => any; toJSON: () => any; } negate: function () {return this;}, diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..bead869eaeb90 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).js @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +//// [a.ts] +export interface A {} + +//// [b.ts] +import * as a from "./a"; + +/** + * See {@link a.A}. + */ +export function foo() {} + + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.foo = foo; +/** + * See {@link a.A}. + */ +function foo() { } diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..5ac6b40e1c04f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).symbols @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === +export interface A {} +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== /b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : Symbol(foo, Decl(b.ts, 0, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..239eddf0ea7ff --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === + +export interface A {} + +=== /b.ts === +import * as a from "./a"; +>a : typeof a + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..bead869eaeb90 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +//// [a.ts] +export interface A {} + +//// [b.ts] +import * as a from "./a"; + +/** + * See {@link a.A}. + */ +export function foo() {} + + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.foo = foo; +/** + * See {@link a.A}. + */ +function foo() { } diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..5ac6b40e1c04f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === +export interface A {} +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== /b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : Symbol(foo, Decl(b.ts, 0, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..239eddf0ea7ff --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === + +export interface A {} + +=== /b.ts === +import * as a from "./a"; +>a : typeof a + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt new file mode 100644 index 0000000000000..f9f9a2d8d5885 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt @@ -0,0 +1,33 @@ +a.js(4,1): error TS2322: Type '(content: string, rest_0?: boolean | undefined) => string' is not assignable to type '(a: string | number, ...rest: unknown[]) => string'. + Types of parameters 'content' and 'a' are incompatible. + Type 'string | number' is not assignable to type 'string'. + Type 'number' is not assignable to type 'string'. +a.js(9,7): error TS2322: Type '(content: string) => string' is not assignable to type '(content: string | number) => string'. + Types of parameters 'content' and 'content' are incompatible. + Type 'string | number' is not assignable to type 'string'. + Type 'number' is not assignable to type 'string'. + + +==== a.js (2 errors) ==== + /** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ + const context = { f: (a) => "" }; + + context.f = + ~~~~~~~~~ +!!! error TS2322: Type '(content: string, rest_0?: boolean | undefined) => string' is not assignable to type '(a: string | number, ...rest: unknown[]) => string'. +!!! error TS2322: Types of parameters 'content' and 'a' are incompatible. +!!! error TS2322: Type 'string | number' is not assignable to type 'string'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + /** @type {(content: string, ...rest: [boolean?]) => string} */ + (content, ...rest) => content.toUpperCase() + rest.length; + + /** @type {(content: string | number) => string} */ + const g = + ~ +!!! error TS2322: Type '(content: string) => string' is not assignable to type '(content: string | number) => string'. +!!! error TS2322: Types of parameters 'content' and 'content' are incompatible. +!!! error TS2322: Type 'string | number' is not assignable to type 'string'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + /** @type {(content: string) => string} */ + (content) => content.toUpperCase(); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols new file mode 100644 index 0000000000000..15ffe15bb65e2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts] //// + +=== a.js === +/** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ +const context = { f: (a) => "" }; +>context : Symbol(context, Decl(a.js, 1, 5)) +>f : Symbol(f, Decl(a.js, 1, 17)) +>a : Symbol(a, Decl(a.js, 1, 22)) + +context.f = +>context.f : Symbol(f, Decl(a.js, 0, 12)) +>context : Symbol(context, Decl(a.js, 1, 5)) +>f : Symbol(f, Decl(a.js, 0, 12)) + + /** @type {(content: string, ...rest: [boolean?]) => string} */ + (content, ...rest) => content.toUpperCase() + rest.length; +>content : Symbol(content, Decl(a.js, 5, 5)) +>rest : Symbol(rest, Decl(a.js, 5, 13)) +>content.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>content : Symbol(content, Decl(a.js, 5, 5)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>rest.length : Symbol(length) +>rest : Symbol(rest, Decl(a.js, 5, 13)) +>length : Symbol(length) + +/** @type {(content: string | number) => string} */ +const g = +>g : Symbol(g, Decl(a.js, 8, 5)) + + /** @type {(content: string) => string} */ + (content) => content.toUpperCase(); +>content : Symbol(content, Decl(a.js, 10, 5)) +>content.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>content : Symbol(content, Decl(a.js, 10, 5)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types new file mode 100644 index 0000000000000..6defe743de587 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts] //// + +=== a.js === +/** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ +const context = { f: (a) => "" }; +>context : { f: (a: string | number, ...rest: unknown[]) => string; } +>{ f: (a) => "" } : { f: (a: string | number) => string; } +>f : (a: string | number) => string +>(a) => "" : (a: string | number) => string +>a : string | number +>"" : "" + +context.f = +>context.f = /** @type {(content: string, ...rest: [boolean?]) => string} */ (content, ...rest) => content.toUpperCase() + rest.length : (content: string, rest_0?: boolean | undefined) => string +>context.f : (a: string | number, ...rest: unknown[]) => string +>context : { f: (a: string | number, ...rest: unknown[]) => string; } +>f : (a: string | number, ...rest: unknown[]) => string + + /** @type {(content: string, ...rest: [boolean?]) => string} */ + (content, ...rest) => content.toUpperCase() + rest.length; +>(content, ...rest) => content.toUpperCase() + rest.length : (content: string, rest_0?: boolean | undefined) => string +>content : string +>rest : [(boolean | undefined)?] +>content.toUpperCase() + rest.length : string +>content.toUpperCase() : string +>content.toUpperCase : () => string +>content : string +>toUpperCase : () => string +>rest.length : 0 | 1 +>rest : [(boolean | undefined)?] +>length : 0 | 1 + +/** @type {(content: string | number) => string} */ +const g = +>g : (content: string | number) => string + + /** @type {(content: string) => string} */ + (content) => content.toUpperCase(); +>(content) => content.toUpperCase() : (content: string) => string +>content : string +>content.toUpperCase() : string +>content.toUpperCase : () => string +>content : string +>toUpperCase : () => string + diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).errors.txt new file mode 100644 index 0000000000000..191dc50e4166c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).errors.txt @@ -0,0 +1,33 @@ +jsxImportSourceNonPragmaComment.tsx(3,21): error TS2307: Cannot find module '@emotion/react' or its corresponding type declarations. +jsxImportSourceNonPragmaComment.tsx(7,5): error TS2875: This JSX tag requires the module path '@emotion/react/jsx-runtime' to exist, but none could be found. Make sure you have types for the appropriate package installed. +jsxImportSourceNonPragmaComment.tsx(7,5): error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists. + + +==== jsxImportSourceNonPragmaComment.tsx (3 errors) ==== + /* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ + /** @jsxImportSource @emotion/react */ + import { css } from "@emotion/react"; + ~~~~~~~~~~~~~~~~ +!!! error TS2307: Cannot find module '@emotion/react' or its corresponding type declarations. + + export default function Component() { + return ( + + ~~~~~~ +!!! error TS2875: This JSX tag requires the module path '@emotion/react/jsx-runtime' to exist, but none could be found. Make sure you have types for the appropriate package installed. + ~~~~~~ +!!! error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists. + ); + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).js new file mode 100644 index 0000000000000..e58934ed59b6b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +//// [jsxImportSourceNonPragmaComment.tsx] +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; + +export default function Component() { + return ( + + ); +} + +//// [jsxImportSourceNonPragmaComment.jsx] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = Component; +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +const react_1 = require("@emotion/react"); +function Component() { + return (); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).symbols new file mode 100644 index 0000000000000..d12b587e7c215 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).symbols @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +=== jsxImportSourceNonPragmaComment.tsx === +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; +>css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 8)) + +export default function Component() { +>Component : Symbol(Component, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 37)) + + return ( + css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 6, 10)) +>css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 8)) + + color: red; + `} + /> + ); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).types new file mode 100644 index 0000000000000..5300452403d62 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +=== jsxImportSourceNonPragmaComment.tsx === +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; +>css : any + +export default function Component() { +>Component : () => any + + return ( +>( ) : any + + : any +>input : any + + css={css` +>css : any +>css` color: red; ` : any +>css : any +>` color: red; ` : "\n color: red;\n " + + color: red; + `} + /> + ); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..191dc50e4166c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt @@ -0,0 +1,33 @@ +jsxImportSourceNonPragmaComment.tsx(3,21): error TS2307: Cannot find module '@emotion/react' or its corresponding type declarations. +jsxImportSourceNonPragmaComment.tsx(7,5): error TS2875: This JSX tag requires the module path '@emotion/react/jsx-runtime' to exist, but none could be found. Make sure you have types for the appropriate package installed. +jsxImportSourceNonPragmaComment.tsx(7,5): error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists. + + +==== jsxImportSourceNonPragmaComment.tsx (3 errors) ==== + /* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ + /** @jsxImportSource @emotion/react */ + import { css } from "@emotion/react"; + ~~~~~~~~~~~~~~~~ +!!! error TS2307: Cannot find module '@emotion/react' or its corresponding type declarations. + + export default function Component() { + return ( + + ~~~~~~ +!!! error TS2875: This JSX tag requires the module path '@emotion/react/jsx-runtime' to exist, but none could be found. Make sure you have types for the appropriate package installed. + ~~~~~~ +!!! error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists. + ); + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).js new file mode 100644 index 0000000000000..e58934ed59b6b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +//// [jsxImportSourceNonPragmaComment.tsx] +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; + +export default function Component() { + return ( + + ); +} + +//// [jsxImportSourceNonPragmaComment.jsx] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = Component; +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +const react_1 = require("@emotion/react"); +function Component() { + return (); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..d12b587e7c215 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).symbols @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +=== jsxImportSourceNonPragmaComment.tsx === +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; +>css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 8)) + +export default function Component() { +>Component : Symbol(Component, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 37)) + + return ( + css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 6, 10)) +>css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 8)) + + color: red; + `} + /> + ); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).types new file mode 100644 index 0000000000000..5300452403d62 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +=== jsxImportSourceNonPragmaComment.tsx === +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; +>css : any + +export default function Component() { +>Component : () => any + + return ( +>( ) : any + + : any +>input : any + + css={css` +>css : any +>css` color: red; ` : any +>css : any +>` color: red; ` : "\n color: red;\n " + + color: red; + `} + /> + ); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).js new file mode 100644 index 0000000000000..4c58e6e84ff1d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx] //// + +//// [index.tsx] +declare namespace JSX { + interface IntrinsicElements extends Record {} +} + +; + + +//// [index.jsx] +"use strict"; +; diff --git a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).symbols new file mode 100644 index 0000000000000..c42caaed5098d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).symbols @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx] //// + +=== index.tsx === +declare namespace JSX { +>JSX : Symbol(JSX, Decl(index.tsx, 0, 0)) + + interface IntrinsicElements extends Record {} +>IntrinsicElements : Symbol(IntrinsicElements, Decl(index.tsx, 0, 23)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +} + +; +>a : Symbol(JSX.IntrinsicElements, Decl(index.tsx, 0, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).types new file mode 100644 index 0000000000000..30632f23d7dc4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).types @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx] //// + +=== index.tsx === +declare namespace JSX { + interface IntrinsicElements extends Record {} +} + +; +> : error +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).js new file mode 100644 index 0000000000000..4c58e6e84ff1d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx] //// + +//// [index.tsx] +declare namespace JSX { + interface IntrinsicElements extends Record {} +} + +; + + +//// [index.jsx] +"use strict"; +; diff --git a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c42caaed5098d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).symbols @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx] //// + +=== index.tsx === +declare namespace JSX { +>JSX : Symbol(JSX, Decl(index.tsx, 0, 0)) + + interface IntrinsicElements extends Record {} +>IntrinsicElements : Symbol(IntrinsicElements, Decl(index.tsx, 0, 23)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +} + +; +>a : Symbol(JSX.IntrinsicElements, Decl(index.tsx, 0, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types new file mode 100644 index 0000000000000..30632f23d7dc4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/jsxIntrinsicElementsExtendsRecord.tsx] //// + +=== index.tsx === +declare namespace JSX { + interface IntrinsicElements extends Record {} +} + +; +> : error +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt index 9808b4f1f9122..d86789c55c7e6 100644 --- a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt @@ -1,9 +1,10 @@ keyofGenericExtendingClassDoubleLayer.ts(2,12): error TS2564: Property 'createdAt' has no initializer and is not definitely assigned in the constructor. -keyofGenericExtendingClassDoubleLayer.ts(9,7): error TS5115: Instantiations of the following types appear infinitely circular: 'Model', 'ModelAttributes', 'Exclude'. +keyofGenericExtendingClassDoubleLayer.ts(9,7): error TS2589: Type instantiation is excessively deep and possibly infinite. keyofGenericExtendingClassDoubleLayer.ts(10,12): error TS2564: Property 'age' has no initializer and is not definitely assigned in the constructor. +keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS2589: Type instantiation is excessively deep and possibly infinite. -==== keyofGenericExtendingClassDoubleLayer.ts (3 errors) ==== +==== keyofGenericExtendingClassDoubleLayer.ts (4 errors) ==== class Model { public createdAt: Date; ~~~~~~~~~ @@ -16,13 +17,15 @@ keyofGenericExtendingClassDoubleLayer.ts(10,12): error TS2564: Property 'age' ha class PersonModel extends AutoModel { ~~~~~~~~~~~ -!!! error TS5115: Instantiations of the following types appear infinitely circular: 'Model', 'ModelAttributes', 'Exclude'. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. public age: number; ~~~ !!! error TS2564: Property 'age' has no initializer and is not definitely assigned in the constructor. toJson() { let x: keyof this = 'createdAt'; + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. } } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..44b9fe50fa70d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,14 @@ +keyofIndexSignatureCycleCheckOrder.ts(7,7): error TS2322: Type '123' is not assignable to type 'never'. + + +==== keyofIndexSignatureCycleCheckOrder.ts (1 errors) ==== + // S and the index signature of C depend on each other. Resolving the members + // of C first gives S from the part of them available so far, and resolving S + // first must give the same result rather than fail it as circular. + + interface C { [k: string]: S; } + type S = keyof C; + const k: S = 123; + ~ +!!! error TS2322: Type '123' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..826be2b914e3b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).symbols @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 15)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + +type S = keyof C; +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) + +const k: S = 123; +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 6, 5)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..d43b1450f3a46 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).types @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>k : string + +type S = keyof C; +>S : never + +const k: S = 123; +>k : never +>123 : 123 + diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..44b9fe50fa70d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,14 @@ +keyofIndexSignatureCycleCheckOrder.ts(7,7): error TS2322: Type '123' is not assignable to type 'never'. + + +==== keyofIndexSignatureCycleCheckOrder.ts (1 errors) ==== + // S and the index signature of C depend on each other. Resolving the members + // of C first gives S from the part of them available so far, and resolving S + // first must give the same result rather than fail it as circular. + + interface C { [k: string]: S; } + type S = keyof C; + const k: S = 123; + ~ +!!! error TS2322: Type '123' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..826be2b914e3b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 15)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + +type S = keyof C; +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) + +const k: S = 123; +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 6, 5)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..d43b1450f3a46 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>k : string + +type S = keyof C; +>S : never + +const k: S = 123; +>k : never +>123 : 123 + diff --git a/tsc/testdata/baselines/reference/compiler/largeControlFlowGraph.types b/tsc/testdata/baselines/reference/compiler/largeControlFlowGraph.types index 3880df26550f7..9ed5668ae6c80 100644 --- a/tsc/testdata/baselines/reference/compiler/largeControlFlowGraph.types +++ b/tsc/testdata/baselines/reference/compiler/largeControlFlowGraph.types @@ -10,14000 +10,14000 @@ const data = []; data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 data[0] = 0; >data[0] = 0 : 0 >data[0] : any ->data : any +>data : any[] >0 : 0 >0 : 0 diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt new file mode 100644 index 0000000000000..c1b01f83c3c86 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt @@ -0,0 +1,26 @@ +lateBoundMutualMemberTables.ts(6,8): error TS2339: Property 'by' does not exist on type 'B<"b">'. +lateBoundMutualMemberTables.ts(15,21): error TS2339: Property 'fromA2' does not exist on type 'A<"a">'. + + +==== lateBoundMutualMemberTables.ts (2 errors) ==== + declare const a: A<"a">; + declare const b: B<"b">; + declare class A { + x: T; + [b.y]: "fromB"; + [b.by]: "fromB2"; + ~~ +!!! error TS2339: Property 'by' does not exist on type 'B<"b">'. + } + declare class B { + y: T; + [a.x]: "fromA"; + [a.b]: "fromA2"; + } + export const v1 = a.b; + export const v2 = b.a; + export const v3 = a.fromA2; + ~~~~~~ +!!! error TS2339: Property 'fromA2' does not exist on type 'A<"a">'. + export const v4 = b.fromB; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.js b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.js new file mode 100644 index 0000000000000..aea4e1ea51859 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.js @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/lateBoundMutualMemberTables.ts] //// + +//// [lateBoundMutualMemberTables.ts] +declare const a: A<"a">; +declare const b: B<"b">; +declare class A { + x: T; + [b.y]: "fromB"; + [b.by]: "fromB2"; +} +declare class B { + y: T; + [a.x]: "fromA"; + [a.b]: "fromA2"; +} +export const v1 = a.b; +export const v2 = b.a; +export const v3 = a.fromA2; +export const v4 = b.fromB; + + +//// [lateBoundMutualMemberTables.js] +export const v1 = a.b; +export const v2 = b.a; +export const v3 = a.fromA2; +export const v4 = b.fromB; + + +//// [lateBoundMutualMemberTables.d.ts] +export declare const v1: "fromB"; +export declare const v2: "fromA"; +export declare const v3: any; +export declare const v4: "fromA2"; diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.symbols b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.symbols new file mode 100644 index 0000000000000..24eba3a29f260 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.symbols @@ -0,0 +1,71 @@ +//// [tests/cases/compiler/lateBoundMutualMemberTables.ts] //// + +=== lateBoundMutualMemberTables.ts === +declare const a: A<"a">; +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>A : Symbol(A, Decl(lateBoundMutualMemberTables.ts, 1, 24)) + +declare const b: B<"b">; +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>B : Symbol(B, Decl(lateBoundMutualMemberTables.ts, 6, 1)) + +declare class A { +>A : Symbol(A, Decl(lateBoundMutualMemberTables.ts, 1, 24)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 2, 16)) + + x: T; +>x : Symbol(A.x, Decl(lateBoundMutualMemberTables.ts, 2, 20)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 2, 16)) + + [b.y]: "fromB"; +>[b.y] : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +>b.y : Symbol(B.y, Decl(lateBoundMutualMemberTables.ts, 7, 20)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>y : Symbol(B.y, Decl(lateBoundMutualMemberTables.ts, 7, 20)) + + [b.by]: "fromB2"; +>[b.by] : Symbol(A[b.by], Decl(lateBoundMutualMemberTables.ts, 4, 19)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +} +declare class B { +>B : Symbol(B, Decl(lateBoundMutualMemberTables.ts, 6, 1)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 7, 16)) + + y: T; +>y : Symbol(B.y, Decl(lateBoundMutualMemberTables.ts, 7, 20)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 7, 16)) + + [a.x]: "fromA"; +>[a.x] : Symbol(B[a.x], Decl(lateBoundMutualMemberTables.ts, 8, 9)) +>a.x : Symbol(A.x, Decl(lateBoundMutualMemberTables.ts, 2, 20)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>x : Symbol(A.x, Decl(lateBoundMutualMemberTables.ts, 2, 20)) + + [a.b]: "fromA2"; +>[a.b] : Symbol(B[a.b], Decl(lateBoundMutualMemberTables.ts, 9, 19)) +>a.b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +} +export const v1 = a.b; +>v1 : Symbol(v1, Decl(lateBoundMutualMemberTables.ts, 12, 12)) +>a.b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) + +export const v2 = b.a; +>v2 : Symbol(v2, Decl(lateBoundMutualMemberTables.ts, 13, 12)) +>b.a : Symbol(B[a.x], Decl(lateBoundMutualMemberTables.ts, 8, 9)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>a : Symbol(B[a.x], Decl(lateBoundMutualMemberTables.ts, 8, 9)) + +export const v3 = a.fromA2; +>v3 : Symbol(v3, Decl(lateBoundMutualMemberTables.ts, 14, 12)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) + +export const v4 = b.fromB; +>v4 : Symbol(v4, Decl(lateBoundMutualMemberTables.ts, 15, 12)) +>b.fromB : Symbol(B[a.b], Decl(lateBoundMutualMemberTables.ts, 9, 19)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>fromB : Symbol(B[a.b], Decl(lateBoundMutualMemberTables.ts, 9, 19)) + diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.types b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.types new file mode 100644 index 0000000000000..24f60ac31fc98 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.types @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/lateBoundMutualMemberTables.ts] //// + +=== lateBoundMutualMemberTables.ts === +declare const a: A<"a">; +>a : A<"a"> + +declare const b: B<"b">; +>b : B<"b"> + +declare class A { +>A : A + + x: T; +>x : T + + [b.y]: "fromB"; +>[b.y] : "fromB" +>b.y : "b" +>b : B<"b"> +>y : "b" + + [b.by]: "fromB2"; +>[b.by] : "fromB2" +>b.by : any +>b : B<"b"> +>by : any +} +declare class B { +>B : B + + y: T; +>y : T + + [a.x]: "fromA"; +>[a.x] : "fromA" +>a.x : "a" +>a : A<"a"> +>x : "a" + + [a.b]: "fromA2"; +>[a.b] : "fromA2" +>a.b : "fromB" +>a : A<"a"> +>b : "fromB" +} +export const v1 = a.b; +>v1 : "fromB" +>a.b : "fromB" +>a : A<"a"> +>b : "fromB" + +export const v2 = b.a; +>v2 : "fromA" +>b.a : "fromA" +>b : B<"b"> +>a : "fromA" + +export const v3 = a.fromA2; +>v3 : any +>a.fromA2 : any +>a : A<"a"> +>fromA2 : any + +export const v4 = b.fromB; +>v4 : "fromA2" +>b.fromB : "fromA2" +>b : B<"b"> +>fromB : "fromA2" + diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt new file mode 100644 index 0000000000000..a11d3142ac85e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt @@ -0,0 +1,18 @@ +limitDeepInstantiations.ts(4,5): error TS2589: Type instantiation is excessively deep and possibly infinite. +limitDeepInstantiations.ts(4,9): error TS2589: Type instantiation is excessively deep and possibly infinite. +limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + + +==== limitDeepInstantiations.ts (3 errors) ==== + // Repro from #14837 + + type Foo = { "true": Foo> }[T]; + let f1: Foo<"true", {}>; + ~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + let f2: Foo<"false", {}>; + ~~~~~~~ +!!! error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).js new file mode 100644 index 0000000000000..5c149c0177558 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).js @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/limitDeepInstantiations.ts] //// + +//// [limitDeepInstantiations.ts] +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +let f1: Foo<"true", {}>; +let f2: Foo<"false", {}>; + + +//// [limitDeepInstantiations.js] +"use strict"; +// Repro from #14837 +let f1; +let f2; diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).symbols new file mode 100644 index 0000000000000..73413334b6b82 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).symbols @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/limitDeepInstantiations.ts] //// + +=== limitDeepInstantiations.ts === +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) +>B : Symbol(B, Decl(limitDeepInstantiations.ts, 2, 26)) +>"true" : Symbol("true", Decl(limitDeepInstantiations.ts, 2, 33)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) +>B : Symbol(B, Decl(limitDeepInstantiations.ts, 2, 26)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) + +let f1: Foo<"true", {}>; +>f1 : Symbol(f1, Decl(limitDeepInstantiations.ts, 3, 3)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) + +let f2: Foo<"false", {}>; +>f2 : Symbol(f2, Decl(limitDeepInstantiations.ts, 4, 3)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).types new file mode 100644 index 0000000000000..520205007876c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).types @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/limitDeepInstantiations.ts] //// + +=== limitDeepInstantiations.ts === +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +>Foo : Foo +>"true" : Foo> + +let f1: Foo<"true", {}>; +>f1 : any + +let f2: Foo<"false", {}>; +>f2 : unknown + diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..a11d3142ac85e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt @@ -0,0 +1,18 @@ +limitDeepInstantiations.ts(4,5): error TS2589: Type instantiation is excessively deep and possibly infinite. +limitDeepInstantiations.ts(4,9): error TS2589: Type instantiation is excessively deep and possibly infinite. +limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + + +==== limitDeepInstantiations.ts (3 errors) ==== + // Repro from #14837 + + type Foo = { "true": Foo> }[T]; + let f1: Foo<"true", {}>; + ~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + ~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + let f2: Foo<"false", {}>; + ~~~~~~~ +!!! error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).js new file mode 100644 index 0000000000000..5c149c0177558 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).js @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/limitDeepInstantiations.ts] //// + +//// [limitDeepInstantiations.ts] +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +let f1: Foo<"true", {}>; +let f2: Foo<"false", {}>; + + +//// [limitDeepInstantiations.js] +"use strict"; +// Repro from #14837 +let f1; +let f2; diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..73413334b6b82 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).symbols @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/limitDeepInstantiations.ts] //// + +=== limitDeepInstantiations.ts === +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) +>B : Symbol(B, Decl(limitDeepInstantiations.ts, 2, 26)) +>"true" : Symbol("true", Decl(limitDeepInstantiations.ts, 2, 33)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) +>B : Symbol(B, Decl(limitDeepInstantiations.ts, 2, 26)) +>T : Symbol(T, Decl(limitDeepInstantiations.ts, 2, 9)) + +let f1: Foo<"true", {}>; +>f1 : Symbol(f1, Decl(limitDeepInstantiations.ts, 3, 3)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) + +let f2: Foo<"false", {}>; +>f2 : Symbol(f2, Decl(limitDeepInstantiations.ts, 4, 3)) +>Foo : Symbol(Foo, Decl(limitDeepInstantiations.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).types new file mode 100644 index 0000000000000..520205007876c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).types @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/limitDeepInstantiations.ts] //// + +=== limitDeepInstantiations.ts === +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +>Foo : Foo +>"true" : Foo> + +let f1: Foo<"true", {}>; +>f1 : any + +let f2: Foo<"false", {}>; +>f2 : unknown + diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt index a8197d380d119..d292daee34b3f 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt @@ -5,11 +5,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (9 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (11 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -47,6 +49,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt index a8197d380d119..d292daee34b3f 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt @@ -5,11 +5,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (9 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (11 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -47,6 +49,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt index eef60bbd5ed70..3cb0cbebf0544 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt @@ -6,11 +6,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (10 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (12 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -50,6 +52,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt index eef60bbd5ed70..3cb0cbebf0544 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt @@ -6,11 +6,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (10 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (12 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -50,6 +52,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt index 87e4aba639e60..c355d51097e83 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt @@ -1,14 +1,17 @@ malformedObjectDestructuringAssignmentClassFields.ts(1,3): error TS1136: Property assignment expected. +malformedObjectDestructuringAssignmentClassFields.ts(1,5): error TS7006: Parameter 'A' implicitly has an 'any' type. malformedObjectDestructuringAssignmentClassFields.ts(1,6): error TS1005: ',' expected. malformedObjectDestructuringAssignmentClassFields.ts(1,7): error TS1127: Invalid character. malformedObjectDestructuringAssignmentClassFields.ts(1,10): error TS1109: Expression expected. malformedObjectDestructuringAssignmentClassFields.ts(2,1): error TS1005: ')' expected. -==== malformedObjectDestructuringAssignmentClassFields.ts (5 errors) ==== +==== malformedObjectDestructuringAssignmentClassFields.ts (6 errors) ==== ({x(A.#}= ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7006: Parameter 'A' implicitly has an 'any' type. ~ !!! error TS1005: ',' expected. ~ diff --git a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt index e398726486b0a..a8cd58532857e 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt @@ -1,9 +1,11 @@ malformedObjectDestructuringAssignmentESDecorators.ts(6,12): error TS1136: Property assignment expected. malformedObjectDestructuringAssignmentESDecorators.ts(6,24): error TS1136: Property assignment expected. malformedObjectDestructuringAssignmentESDecorators.ts(6,47): error TS1136: Property assignment expected. +malformedObjectDestructuringAssignmentESDecorators.ts(6,47): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedObjectDestructuringAssignmentESDecorators.ts(6,49): error TS7006: Parameter 'v' implicitly has an 'any' type. -==== malformedObjectDestructuringAssignmentESDecorators.ts (3 errors) ==== +==== malformedObjectDestructuringAssignmentESDecorators.ts (5 errors) ==== declare function dec(...args: any[]): any; @dec @@ -16,6 +18,10 @@ malformedObjectDestructuringAssignmentESDecorators.ts(6,47): error TS1136: Prope !!! error TS1136: Property assignment expected. ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. } } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.errors.txt b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.errors.txt index f9e0d6ab4eac5..bff4827ef673c 100644 --- a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.errors.txt @@ -1,4 +1,4 @@ -/main.ts(7,32): error TS2339: Property 'mb' does not exist on type '{}'. +/main.ts(8,32): error TS2339: Property 'ma' does not exist on type '{}'. ==== /main.ts (1 errors) ==== @@ -9,9 +9,9 @@ export const fromA = MA.pa; export const fromB = MB.pb; export const checkA: 1 = MA.pa.mb; - ~~ -!!! error TS2339: Property 'mb' does not exist on type '{}'. export const checkB: 1 = MB.pb.ma; + ~~ +!!! error TS2339: Property 'ma' does not exist on type '{}'. ==== /ma.js (0 errors) ==== export { v as pa } from "./xa"; diff --git a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.js b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.js index b99218d5bfd65..e7f345491f402 100644 --- a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.js +++ b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.js @@ -185,7 +185,10 @@ exports.checkB = MB.pb.ma; //// [xa.d.ts] export = o; declare const o: { - v: {}; + v: { + pb: {}; + mb: 1; + }; }; //// [ma.d.ts] export { v as pa } from "./xa"; @@ -193,10 +196,7 @@ export declare const ma = 1; //// [xb.d.ts] export = o; declare const o: { - v: { - pa: {}; - ma: 1; - }; + v: {}; }; //// [mb.d.ts] export { v as pb } from "./xb"; @@ -205,10 +205,7 @@ export declare const mb = 1; export = o; declare const o: { v: { - pb: { - pa: {}; - ma: 1; - }; + pb: {}; mb: 1; }; }; @@ -216,7 +213,10 @@ declare const o: { export = o; declare const o: { v: { - pa: {}; + pa: { + pb: {}; + mb: 1; + }; ma: 1; }; }; @@ -236,10 +236,10 @@ export declare const f8 = 8; export declare const f9 = 9; export declare const f10 = 10; //// [main.d.ts] -export declare const fromA: {}; -export declare const fromB: { - pa: {}; - ma: 1; +export declare const fromA: { + pb: {}; + mb: 1; }; +export declare const fromB: {}; export declare const checkA: 1; export declare const checkB: 1; diff --git a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.symbols b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.symbols index 4f7c5a9b9f1d4..6997e4d5a273d 100644 --- a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.symbols +++ b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.symbols @@ -28,17 +28,17 @@ export const fromB = MB.pb; export const checkA: 1 = MA.pa.mb; >checkA : Symbol(checkA, Decl(main.ts, 6, 12)) +>MA.pa.mb : Symbol(mb, Decl(mb.js, 1, 12)) >MA.pa : Symbol(MA.pa, Decl(ma.js, 0, 8)) >MA : Symbol(MA, Decl(main.ts, 2, 6)) >pa : Symbol(MA.pa, Decl(ma.js, 0, 8)) +>mb : Symbol(mb, Decl(mb.js, 1, 12)) export const checkB: 1 = MB.pb.ma; >checkB : Symbol(checkB, Decl(main.ts, 7, 12)) ->MB.pb.ma : Symbol(ma, Decl(ma.js, 1, 12)) >MB.pb : Symbol(MB.pb, Decl(mb.js, 0, 8)) >MB : Symbol(MB, Decl(main.ts, 3, 6)) >pb : Symbol(MB.pb, Decl(mb.js, 0, 8)) ->ma : Symbol(ma, Decl(ma.js, 1, 12)) === /ma.js === export { v as pa } from "./xa"; diff --git a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.types b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.types index 179ce8b0ee07e..49f1de0b3ac44 100644 --- a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.types +++ b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.types @@ -5,8 +5,8 @@ import * as idx from "./index"; >idx : typeof idx const all = { ...idx }; ->all : { a: { pa: {}; ma: 1; }; b: { pb: { pa: {}; ma: 1; }; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } ->{ ...idx } : { a: { pa: {}; ma: 1; }; b: { pb: { pa: {}; ma: 1; }; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } +>all : { a: { pa: { pb: {}; mb: 1; }; ma: 1; }; b: { pb: {}; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } +>{ ...idx } : { a: { pa: { pb: {}; mb: 1; }; ma: 1; }; b: { pb: {}; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } >idx : typeof idx import * as MA from "./ma"; @@ -16,37 +16,37 @@ import * as MB from "./mb"; >MB : typeof MB export const fromA = MA.pa; ->fromA : {} ->MA.pa : {} +>fromA : { pb: {}; mb: 1; } +>MA.pa : { pb: {}; mb: 1; } >MA : typeof MA ->pa : {} +>pa : { pb: {}; mb: 1; } export const fromB = MB.pb; ->fromB : { pa: {}; ma: 1; } ->MB.pb : { pa: {}; ma: 1; } +>fromB : {} +>MB.pb : {} >MB : typeof MB ->pb : { pa: {}; ma: 1; } +>pb : {} export const checkA: 1 = MA.pa.mb; >checkA : 1 ->MA.pa.mb : any ->MA.pa : {} +>MA.pa.mb : 1 +>MA.pa : { pb: {}; mb: 1; } >MA : typeof MA ->pa : {} ->mb : any +>pa : { pb: {}; mb: 1; } +>mb : 1 export const checkB: 1 = MB.pb.ma; >checkB : 1 ->MB.pb.ma : 1 ->MB.pb : { pa: {}; ma: 1; } +>MB.pb.ma : any +>MB.pb : {} >MB : typeof MB ->pb : { pa: {}; ma: 1; } ->ma : 1 +>pb : {} +>ma : any === /ma.js === export { v as pa } from "./xa"; ->v : {} ->pa : {} +>v : { pb: {}; mb: 1; } +>pa : { pb: {}; mb: 1; } export const ma = 1; >ma : 1 @@ -54,8 +54,8 @@ export const ma = 1; === /mb.js === export { v as pb } from "./xb"; ->v : { pa: {}; ma: 1; } ->pb : { pa: {}; ma: 1; } +>v : {} +>pb : {} export const mb = 1; >mb : 1 @@ -68,18 +68,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: {}; } ->{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } ->v : { pb: { pa: {}; ma: 1; }; mb: 1; } ->{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } +>o : { v: { pb: {}; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } +>v : { pb: {}; mb: 1; } +>{ ...M } : { pb: {}; mb: 1; } >M : typeof import("./mb") module.exports = o; ->module.exports = o : { v: {}; } ->module.exports : { v: {}; } ->module : { exports: { v: {}; }; } ->exports : { v: {}; } ->o : { v: {}; } +>module.exports = o : { v: { pb: {}; mb: 1; }; } +>module.exports : { v: { pb: {}; mb: 1; }; } +>module : { exports: { v: { pb: {}; mb: 1; }; }; } +>exports : { v: { pb: {}; mb: 1; }; } +>o : { v: { pb: {}; mb: 1; }; } === /xb.js === /** @type {typeof import("./ma")} */ @@ -88,18 +88,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pa: {}; ma: 1; }; } ->{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } ->v : { pa: {}; ma: 1; } ->{ ...M } : { pa: {}; ma: 1; } +>o : { v: {}; } +>{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>v : { pa: { pb: {}; mb: 1; }; ma: 1; } +>{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } >M : typeof import("./ma") module.exports = o; ->module.exports = o : { v: { pa: {}; ma: 1; }; } ->module.exports : { v: { pa: {}; ma: 1; }; } ->module : { exports: { v: { pa: {}; ma: 1; }; }; } ->exports : { v: { pa: {}; ma: 1; }; } ->o : { v: { pa: {}; ma: 1; }; } +>module.exports = o : { v: {}; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { v: {}; } +>o : { v: {}; } === /ia.js === /** @type {typeof import("./ma")} */ @@ -108,18 +108,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pa: {}; ma: 1; }; } ->{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } ->v : { pa: {}; ma: 1; } ->{ ...M } : { pa: {}; ma: 1; } +>o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>v : { pa: { pb: {}; mb: 1; }; ma: 1; } +>{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } >M : typeof import("./ma") module.exports = o; ->module.exports = o : { v: { pa: {}; ma: 1; }; } ->module.exports : { v: { pa: {}; ma: 1; }; } ->module : { exports: { v: { pa: {}; ma: 1; }; }; } ->exports : { v: { pa: {}; ma: 1; }; } ->o : { v: { pa: {}; ma: 1; }; } +>module.exports = o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module : { exports: { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; }; } +>exports : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } === /ib.js === /** @type {typeof import("./mb")} */ @@ -128,28 +128,28 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } ->v : { pb: { pa: {}; ma: 1; }; mb: 1; } ->{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } +>o : { v: { pb: {}; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } +>v : { pb: {}; mb: 1; } +>{ ...M } : { pb: {}; mb: 1; } >M : typeof import("./mb") module.exports = o; ->module.exports = o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } ->module.exports : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } ->module : { exports: { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; }; } ->exports : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } ->o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module.exports = o : { v: { pb: {}; mb: 1; }; } +>module.exports : { v: { pb: {}; mb: 1; }; } +>module : { exports: { v: { pb: {}; mb: 1; }; }; } +>exports : { v: { pb: {}; mb: 1; }; } +>o : { v: { pb: {}; mb: 1; }; } === /star.js === export { v as a } from "./ia"; ->v : { pa: {}; ma: 1; } ->a : { pa: {}; ma: 1; } +>v : { pa: { pb: {}; mb: 1; }; ma: 1; } +>a : { pa: { pb: {}; mb: 1; }; ma: 1; } === /index.js === export { v as b } from "./ib"; ->v : { pb: { pa: {}; ma: 1; }; mb: 1; } ->b : { pb: { pa: {}; ma: 1; }; mb: 1; } +>v : { pb: {}; mb: 1; } +>b : { pb: {}; mb: 1; } export * from "./star"; export const f1 = 1; diff --git a/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt new file mode 100644 index 0000000000000..dfe01f2eea345 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt @@ -0,0 +1,29 @@ +narrowedNeverAfterLoopWithAndCondition.ts(9,19): error TS2339: Property 'last_ref' does not exist on type 'never'. +narrowedNeverAfterLoopWithAndCondition.ts(17,19): error TS2339: Property 'last_ref' does not exist on type 'never'. + + +==== narrowedNeverAfterLoopWithAndCondition.ts (2 errors) ==== + // value_def is never inside the if. With a && condition, main and + // Strada leak the loop analysis's incomplete never placeholder + // (silentNever), so the property access is silently allowed and only + // the assignment errors. With `while (x)` they report the access. + function f(x: boolean, y: boolean) { + let value_def: { last_ref: boolean } | null = null; + if (value_def) { + while (x && y); + value_def.last_ref = false; + ~~~~~~~~ +!!! error TS2339: Property 'last_ref' does not exist on type 'never'. + } + } + + function g(x: boolean) { + let value_def: { last_ref: boolean } | null = null; + if (value_def) { + while (x); + value_def.last_ref = false; + ~~~~~~~~ +!!! error TS2339: Property 'last_ref' does not exist on type 'never'. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.symbols b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.symbols new file mode 100644 index 0000000000000..4320e2396f293 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.symbols @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts] //// + +=== narrowedNeverAfterLoopWithAndCondition.ts === +// value_def is never inside the if. With a && condition, main and +// Strada leak the loop analysis's incomplete never placeholder +// (silentNever), so the property access is silently allowed and only +// the assignment errors. With `while (x)` they report the access. +function f(x: boolean, y: boolean) { +>f : Symbol(f, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 0, 0)) +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 11)) +>y : Symbol(y, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 22)) + + let value_def: { last_ref: boolean } | null = null; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 7)) +>last_ref : Symbol(last_ref, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 20)) + + if (value_def) { +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 7)) + + while (x && y); +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 11)) +>y : Symbol(y, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 22)) + + value_def.last_ref = false; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 7)) + } +} + +function g(x: boolean) { +>g : Symbol(g, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 10, 1)) +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 12, 11)) + + let value_def: { last_ref: boolean } | null = null; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 7)) +>last_ref : Symbol(last_ref, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 20)) + + if (value_def) { +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 7)) + + while (x); +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 12, 11)) + + value_def.last_ref = false; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 7)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.types b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.types new file mode 100644 index 0000000000000..ec7b2e4bfcb90 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.types @@ -0,0 +1,56 @@ +//// [tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts] //// + +=== narrowedNeverAfterLoopWithAndCondition.ts === +// value_def is never inside the if. With a && condition, main and +// Strada leak the loop analysis's incomplete never placeholder +// (silentNever), so the property access is silently allowed and only +// the assignment errors. With `while (x)` they report the access. +function f(x: boolean, y: boolean) { +>f : (x: boolean, y: boolean) => void +>x : boolean +>y : boolean + + let value_def: { last_ref: boolean } | null = null; +>value_def : { last_ref: boolean; } | null +>last_ref : boolean + + if (value_def) { +>value_def : null + + while (x && y); +>x && y : boolean +>x : boolean +>y : boolean + + value_def.last_ref = false; +>value_def.last_ref = false : false +>value_def.last_ref : any +>value_def : never +>last_ref : any +>false : false + } +} + +function g(x: boolean) { +>g : (x: boolean) => void +>x : boolean + + let value_def: { last_ref: boolean } | null = null; +>value_def : { last_ref: boolean; } | null +>last_ref : boolean + + if (value_def) { +>value_def : null + + while (x); +>x : boolean + + value_def.last_ref = false; +>value_def.last_ref = false : false +>value_def.last_ref : any +>value_def : never +>last_ref : any +>false : false + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..3d0dd7f90da44 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,75 @@ +nestedCallContextualTypeCheckOrder.ts(12,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(13,10): error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(14,15): error TS7006: Parameter 'x' implicitly has an 'any' type. +nestedCallContextualTypeCheckOrder.ts(15,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(16,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(17,10): error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. + Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrder.ts (6 errors) ==== + // A generic call whose contextual type comes from an enclosing call is + // resolved after it, whichever is queried first, through every expression + // that passes the contextual type on. + + declare function outer(cb: (x: T) => void, v: T): void; + declare function outerObj(o: { cb: (x: T) => void; v: T }): void; + declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; + declare function wrap(f: U): U; + declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; + declare function tagWrap(s: TemplateStringsArray, f: U): U; + + outer(wrap((x) => x.toFixed())!, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2345: Types of property 'cb' are incompatible. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(([wrap((x) => x.toFixed())] as const)[0], 1); + ~ +!!! error TS7006: Parameter 'x' implicitly has an 'any' type. + tag`${wrap((x) => x.toFixed())}${1}`; + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(tagWrap`${(x) => x.toFixed()}`, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); + ~~~~~~~~ +!!! error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. +!!! error TS2345: Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..c570d8990f40c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).symbols @@ -0,0 +1,103 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 31)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 45)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>o : Symbol(o, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 29)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 39)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 53)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>g : Symbol(g, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 29)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 49)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 64)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 24)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 48)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 28)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 52)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) + +outer(wrap((x) => x.toFixed())!, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 15)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 47)) + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>const : Symbol(const) +>0 : Symbol(0) + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..2d6dc49211323 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).types @@ -0,0 +1,134 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : (cb: (x: T) => void, v: T) => void +>cb : (x: T) => void +>x : T +>v : T + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>o : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>g : () => Generator<(x: T) => void> +>x : T +>v : T + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>s : TemplateStringsArray +>cb : (x: T) => void +>x : T +>v : T + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : (s: TemplateStringsArray, f: U) => U +>s : TemplateStringsArray +>f : U + +outer(wrap((x) => x.toFixed())!, 1); +>outer(wrap((x) => x.toFixed())!, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>wrap((x) => x.toFixed())! : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }) : void +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>{ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 } : { cb: (x: never) => never; v: number; } +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer(([wrap((x) => x.toFixed())] as const)[0], 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>([wrap((x) => x.toFixed())] as const)[0] : (x: any) => any +>([wrap((x) => x.toFixed())] as const) : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] as const : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] : readonly [(x: any) => any] +>wrap((x) => x.toFixed()) : (x: any) => any +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: any) => any +>x : any +>x.toFixed() : any +>x.toFixed : any +>x : any +>toFixed : any +>0 : 0 +>1 : 1 + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag`${wrap((x) => x.toFixed())}${1}` : void +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>`${wrap((x) => x.toFixed())}${1}` : string +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer(tagWrap`${(x) => x.toFixed()}`, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>tagWrap`${(x) => x.toFixed()}` : (x: never) => never +>tagWrap : (s: TemplateStringsArray, f: U) => U +>`${(x) => x.toFixed()}` : string +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1) : void +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>function* () { yield wrap((x) => x.toFixed()); } : () => Generator<(x: never) => never, void, any> +>yield wrap((x) => x.toFixed()) : any +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..3d0dd7f90da44 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,75 @@ +nestedCallContextualTypeCheckOrder.ts(12,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(13,10): error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(14,15): error TS7006: Parameter 'x' implicitly has an 'any' type. +nestedCallContextualTypeCheckOrder.ts(15,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(16,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(17,10): error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. + Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrder.ts (6 errors) ==== + // A generic call whose contextual type comes from an enclosing call is + // resolved after it, whichever is queried first, through every expression + // that passes the contextual type on. + + declare function outer(cb: (x: T) => void, v: T): void; + declare function outerObj(o: { cb: (x: T) => void; v: T }): void; + declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; + declare function wrap(f: U): U; + declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; + declare function tagWrap(s: TemplateStringsArray, f: U): U; + + outer(wrap((x) => x.toFixed())!, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2345: Types of property 'cb' are incompatible. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(([wrap((x) => x.toFixed())] as const)[0], 1); + ~ +!!! error TS7006: Parameter 'x' implicitly has an 'any' type. + tag`${wrap((x) => x.toFixed())}${1}`; + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(tagWrap`${(x) => x.toFixed()}`, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); + ~~~~~~~~ +!!! error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. +!!! error TS2345: Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c570d8990f40c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,103 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 31)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 45)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>o : Symbol(o, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 29)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 39)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 53)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>g : Symbol(g, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 29)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 49)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 64)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 24)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 48)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 28)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 52)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) + +outer(wrap((x) => x.toFixed())!, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 15)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 47)) + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>const : Symbol(const) +>0 : Symbol(0) + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..2d6dc49211323 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,134 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : (cb: (x: T) => void, v: T) => void +>cb : (x: T) => void +>x : T +>v : T + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>o : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>g : () => Generator<(x: T) => void> +>x : T +>v : T + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>s : TemplateStringsArray +>cb : (x: T) => void +>x : T +>v : T + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : (s: TemplateStringsArray, f: U) => U +>s : TemplateStringsArray +>f : U + +outer(wrap((x) => x.toFixed())!, 1); +>outer(wrap((x) => x.toFixed())!, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>wrap((x) => x.toFixed())! : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }) : void +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>{ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 } : { cb: (x: never) => never; v: number; } +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer(([wrap((x) => x.toFixed())] as const)[0], 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>([wrap((x) => x.toFixed())] as const)[0] : (x: any) => any +>([wrap((x) => x.toFixed())] as const) : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] as const : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] : readonly [(x: any) => any] +>wrap((x) => x.toFixed()) : (x: any) => any +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: any) => any +>x : any +>x.toFixed() : any +>x.toFixed : any +>x : any +>toFixed : any +>0 : 0 +>1 : 1 + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag`${wrap((x) => x.toFixed())}${1}` : void +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>`${wrap((x) => x.toFixed())}${1}` : string +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer(tagWrap`${(x) => x.toFixed()}`, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>tagWrap`${(x) => x.toFixed()}` : (x: never) => never +>tagWrap : (s: TemplateStringsArray, f: U) => U +>`${(x) => x.toFixed()}` : string +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1) : void +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>function* () { yield wrap((x) => x.toFixed()); } : () => Generator<(x: never) => never, void, any> +>yield wrap((x) => x.toFixed()) : any +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).errors.txt new file mode 100644 index 0000000000000..c6184fc4a6ce6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).errors.txt @@ -0,0 +1,35 @@ +nestedCallContextualTypeCheckOrderJsx.tsx(11,18): error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrderJsx.tsx(12,12): error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrderJsx.tsx (2 errors) ==== + // A generic call in a JSX attribute is resolved after the element, whichever + // is queried first. + + declare namespace JSX { + interface Element {} + interface IntrinsicElements {} + } + declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; + declare function wrap(f: U): U; + + const a = x.toFixed())} v={1} />; + ~~ +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. +!!! related TS6500 nestedCallContextualTypeCheckOrderJsx.tsx:8:36: The expected type comes from property 'cb' which is declared here on type '{ cb: (x: number) => void; v: number; }' + const b = x.toFixed()) }} v={1} />; + ~~~~~ +!!! error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2322: Types of property 'cb' are incompatible. +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).symbols new file mode 100644 index 0000000000000..a6cd6b32cc61a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).symbols @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) + + interface Element {} +>Element : Symbol(Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + + interface IntrinsicElements {} +>IntrinsicElements : Symbol(IntrinsicElements, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 4, 24)) +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>props : Symbol(props, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 26)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 34)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 40)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) +>Element : Symbol(JSX.Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) + +const a = x.toFixed())} v={1} />; +>a : Symbol(a, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 16)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 46)) + +const b = x.toFixed()) }} v={1} />; +>b : Symbol(b, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 22)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 54)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).types new file mode 100644 index 0000000000000..2f5dff0329e96 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).types @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { + interface Element {} + interface IntrinsicElements {} +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>props : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T +>JSX : any + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +const a = x.toFixed())} v={1} />; +>a : JSX.Element +> x.toFixed())} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +const b = x.toFixed()) }} v={1} />; +>b : JSX.Element +> x.toFixed()) }} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..c6184fc4a6ce6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).errors.txt @@ -0,0 +1,35 @@ +nestedCallContextualTypeCheckOrderJsx.tsx(11,18): error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrderJsx.tsx(12,12): error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrderJsx.tsx (2 errors) ==== + // A generic call in a JSX attribute is resolved after the element, whichever + // is queried first. + + declare namespace JSX { + interface Element {} + interface IntrinsicElements {} + } + declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; + declare function wrap(f: U): U; + + const a = x.toFixed())} v={1} />; + ~~ +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. +!!! related TS6500 nestedCallContextualTypeCheckOrderJsx.tsx:8:36: The expected type comes from property 'cb' which is declared here on type '{ cb: (x: number) => void; v: number; }' + const b = x.toFixed()) }} v={1} />; + ~~~~~ +!!! error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2322: Types of property 'cb' are incompatible. +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..a6cd6b32cc61a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).symbols @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) + + interface Element {} +>Element : Symbol(Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + + interface IntrinsicElements {} +>IntrinsicElements : Symbol(IntrinsicElements, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 4, 24)) +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>props : Symbol(props, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 26)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 34)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 40)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) +>Element : Symbol(JSX.Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) + +const a = x.toFixed())} v={1} />; +>a : Symbol(a, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 16)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 46)) + +const b = x.toFixed()) }} v={1} />; +>b : Symbol(b, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 22)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 54)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).types new file mode 100644 index 0000000000000..2f5dff0329e96 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).types @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { + interface Element {} + interface IntrinsicElements {} +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>props : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T +>JSX : any + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +const a = x.toFixed())} v={1} />; +>a : JSX.Element +> x.toFixed())} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +const b = x.toFixed()) }} v={1} />; +>b : JSX.Element +> x.toFixed()) }} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt new file mode 100644 index 0000000000000..92c6dfe7ad198 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt @@ -0,0 +1,48 @@ +nestedGenericArrayAssignabilityAfterErrors.ts(14,27): error TS2322: Type 'boolean' is not assignable to type 'number'. +nestedGenericArrayAssignabilityAfterErrors.ts(17,17): error TS2322: Type 'boolean' is not assignable to type 'number'. +nestedGenericArrayAssignabilityAfterErrors.ts(23,5): error TS2322: Type 'DataTypeThree' is not assignable to type 'DataTypeThree'. + Type 'number' is not assignable to type 'boolean'. +nestedGenericArrayAssignabilityAfterErrors.ts(28,5): error TS2322: Type 'DataTypeTwo' is not assignable to type 'DataTypeTwo'. + Type 'number' is not assignable to type 'boolean'. + + +==== nestedGenericArrayAssignabilityAfterErrors.ts (4 errors) ==== + // Assigning DataTypeThree to DataTypeThree, and likewise for + // DataTypeTwo, must be reported whether or not earlier assignments errored. + + type TypeA = number; + type TypeB = boolean; + type DataTypeTwo = { + one: Array<{ two: Array }>; + }; + type DataTypeThree = { + one: Array<{ two: Array<{ three: Array }> }>; + }; + + let testingThreeErr: DataTypeThree = { + one: [{ two: [{ three: [true] }] }] + ~~~~ +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + }; + let testingTwoErr: DataTypeTwo = { + one: [{ two: [false] }] + ~~~~~ +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + }; + + let testingThree: DataTypeThree = { + one: [{ two: [{ three: [5] }] }] + }; + let t3a: DataTypeThree = testingThree; + ~~~ +!!! error TS2322: Type 'DataTypeThree' is not assignable to type 'DataTypeThree'. +!!! error TS2322: Type 'number' is not assignable to type 'boolean'. + + let testingTwo: DataTypeTwo = { + one: [{ two: [5] }] + }; + let t2a: DataTypeTwo = testingTwo; + ~~~ +!!! error TS2322: Type 'DataTypeTwo' is not assignable to type 'DataTypeTwo'. +!!! error TS2322: Type 'number' is not assignable to type 'boolean'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.symbols b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.symbols new file mode 100644 index 0000000000000..1ff1f70440332 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.symbols @@ -0,0 +1,98 @@ +//// [tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts] //// + +=== nestedGenericArrayAssignabilityAfterErrors.ts === +// Assigning DataTypeThree to DataTypeThree, and likewise for +// DataTypeTwo, must be reported whether or not earlier assignments errored. + +type TypeA = number; +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + +type TypeB = boolean; +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) + +type DataTypeTwo = { +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 5, 17)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) + + one: Array<{ two: Array }>; +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 5, 45)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 6, 14)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 5, 17)) + +}; +type DataTypeThree = { +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 8, 19)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) + + one: Array<{ two: Array<{ three: Array }> }>; +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 8, 47)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 9, 14)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>three : Symbol(three, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 9, 27)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 8, 19)) + +}; + +let testingThreeErr: DataTypeThree = { +>testingThreeErr : Symbol(testingThreeErr, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 12, 3)) +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [{ three: [true] }] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 12, 45)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 13, 9)) +>three : Symbol(three, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 13, 17)) + +}; +let testingTwoErr: DataTypeTwo = { +>testingTwoErr : Symbol(testingTwoErr, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 15, 3)) +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [false] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 15, 41)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 16, 9)) + +}; + +let testingThree: DataTypeThree = { +>testingThree : Symbol(testingThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 19, 3)) +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [{ three: [5] }] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 19, 42)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 20, 9)) +>three : Symbol(three, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 20, 17)) + +}; +let t3a: DataTypeThree = testingThree; +>t3a : Symbol(t3a, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 22, 3)) +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) +>testingThree : Symbol(testingThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 19, 3)) + +let testingTwo: DataTypeTwo = { +>testingTwo : Symbol(testingTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 24, 3)) +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [5] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 24, 38)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 25, 9)) + +}; +let t2a: DataTypeTwo = testingTwo; +>t2a : Symbol(t2a, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 27, 3)) +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) +>testingTwo : Symbol(testingTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 24, 3)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.types b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.types new file mode 100644 index 0000000000000..387d506bb6a05 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.types @@ -0,0 +1,97 @@ +//// [tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts] //// + +=== nestedGenericArrayAssignabilityAfterErrors.ts === +// Assigning DataTypeThree to DataTypeThree, and likewise for +// DataTypeTwo, must be reported whether or not earlier assignments errored. + +type TypeA = number; +>TypeA : number + +type TypeB = boolean; +>TypeB : boolean + +type DataTypeTwo = { +>DataTypeTwo : DataTypeTwo + + one: Array<{ two: Array }>; +>one : { two: Array; }[] +>two : T[] + +}; +type DataTypeThree = { +>DataTypeThree : DataTypeThree + + one: Array<{ two: Array<{ three: Array }> }>; +>one : { two: Array<{ three: Array; }>; }[] +>two : { three: Array; }[] +>three : T[] + +}; + +let testingThreeErr: DataTypeThree = { +>testingThreeErr : DataTypeThree +>{ one: [{ two: [{ three: [true] }] }]} : { one: { two: { three: boolean[]; }[]; }[]; } + + one: [{ two: [{ three: [true] }] }] +>one : { two: { three: boolean[]; }[]; }[] +>[{ two: [{ three: [true] }] }] : { two: { three: boolean[]; }[]; }[] +>{ two: [{ three: [true] }] } : { two: { three: boolean[]; }[]; } +>two : { three: boolean[]; }[] +>[{ three: [true] }] : { three: boolean[]; }[] +>{ three: [true] } : { three: boolean[]; } +>three : boolean[] +>[true] : boolean[] +>true : true + +}; +let testingTwoErr: DataTypeTwo = { +>testingTwoErr : DataTypeTwo +>{ one: [{ two: [false] }]} : { one: { two: boolean[]; }[]; } + + one: [{ two: [false] }] +>one : { two: boolean[]; }[] +>[{ two: [false] }] : { two: boolean[]; }[] +>{ two: [false] } : { two: boolean[]; } +>two : boolean[] +>[false] : boolean[] +>false : false + +}; + +let testingThree: DataTypeThree = { +>testingThree : DataTypeThree +>{ one: [{ two: [{ three: [5] }] }]} : { one: { two: { three: number[]; }[]; }[]; } + + one: [{ two: [{ three: [5] }] }] +>one : { two: { three: number[]; }[]; }[] +>[{ two: [{ three: [5] }] }] : { two: { three: number[]; }[]; }[] +>{ two: [{ three: [5] }] } : { two: { three: number[]; }[]; } +>two : { three: number[]; }[] +>[{ three: [5] }] : { three: number[]; }[] +>{ three: [5] } : { three: number[]; } +>three : number[] +>[5] : number[] +>5 : 5 + +}; +let t3a: DataTypeThree = testingThree; +>t3a : DataTypeThree +>testingThree : DataTypeThree + +let testingTwo: DataTypeTwo = { +>testingTwo : DataTypeTwo +>{ one: [{ two: [5] }]} : { one: { two: number[]; }[]; } + + one: [{ two: [5] }] +>one : { two: number[]; }[] +>[{ two: [5] }] : { two: number[]; }[] +>{ two: [5] } : { two: number[]; } +>two : number[] +>[5] : number[] +>5 : 5 + +}; +let t2a: DataTypeTwo = testingTwo; +>t2a : DataTypeTwo +>testingTwo : DataTypeTwo + diff --git a/tsc/testdata/baselines/reference/compiler/nestedSpreadsAndWidening.types b/tsc/testdata/baselines/reference/compiler/nestedSpreadsAndWidening.types index 811f7fa0ac83f..939c5597d5f60 100644 --- a/tsc/testdata/baselines/reference/compiler/nestedSpreadsAndWidening.types +++ b/tsc/testdata/baselines/reference/compiler/nestedSpreadsAndWidening.types @@ -120,19 +120,19 @@ declare const step: Action; read({ >read({ ...step, settings: { ...step.settings, input: { ...step.settings.input, k: ['5'] } },}) : void >read : (arg: T) => void ->{ ...step, settings: { ...step.settings, input: { ...step.settings.input, k: ['5'] } },} : { type: "1"; settings: { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; }; } | { type: "2"; settings: { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; }; } | { type: "3"; settings: { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | any | any; } | any | any +>{ ...step, settings: { ...step.settings, input: { ...step.settings.input, k: ['5'] } },} : { type: "1"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "10"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "11"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "2"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "3"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "4"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "5"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "6"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "7"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "8"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } | { type: "9"; settings: { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; }; } ...step, >step : Action settings: { ...step.settings, input: { ...step.settings.input, k: ['5'] } }, ->settings : { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } ->{ ...step.settings, input: { ...step.settings.input, k: ['5'] } } : { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } | { input: { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; }; } +>settings : { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; } +>{ ...step.settings, input: { ...step.settings.input, k: ['5'] } } : { input: { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; }; } >step.settings : ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S1) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S10) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S11) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S2) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S3) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S4) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S5) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S6) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S7) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S8) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S9) >step : Action >settings : ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S1) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S10) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S11) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S2) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S3) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S4) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S5) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S6) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S7) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S8) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S9) ->input : { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } ->{ ...step.settings.input, k: ['5'] } : { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { a: number; k: string[]; } | { a: number; b: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { b: number; c: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { b: number; d: number; k: string[]; } | { c: number; d: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { b: number; e: number; k: string[]; } | { c: number; e: number; k: string[]; } | { d: number; e: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { b: number; f: number; k: string[]; } | { c: number; f: number; k: string[]; } | { d: number; f: number; k: string[]; } | { e: number; f: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { b: number; g: number; k: string[]; } | { c: number; g: number; k: string[]; } | { d: number; g: number; k: string[]; } | { e: number; g: number; k: string[]; } | { f: number; g: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { b: number; h: number; k: string[]; } | { c: number; h: number; k: string[]; } | { d: number; h: number; k: string[]; } | { e: number; h: number; k: string[]; } | { f: number; h: number; k: string[]; } | { g: number; h: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { b: number; i: number; k: string[]; } | { c: number; i: number; k: string[]; } | { d: number; i: number; k: string[]; } | { e: number; i: number; k: string[]; } | { f: number; i: number; k: string[]; } | { g: number; i: number; k: string[]; } | { h: number; i: number; k: string[]; } | { i: number; j: number; k: string[]; } | { i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } | { j: number; k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } +>input : { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } +>{ ...step.settings.input, k: ['5'] } : { k: string[]; } | { a: number; k: string[]; } | { b: number; k: string[]; } | { c: number; k: string[]; } | { d: number; k: string[]; } | { e: number; k: string[]; } | { f: number; k: string[]; } | { g: number; k: string[]; } | { h: number; k: string[]; } | { i: number; k: string[]; } | { j: number; k: string[]; } | { a: number; b: number; k: string[]; } | { a: number; c: number; k: string[]; } | { a: number; d: number; k: string[]; } | { a: number; e: number; k: string[]; } | { a: number; f: number; k: string[]; } | { a: number; g: number; k: string[]; } | { a: number; h: number; k: string[]; } | { a: number; i: number; k: string[]; } | { a: number; j: number; k: string[]; } | { b: number; c: number; k: string[]; } | { b: number; d: number; k: string[]; } | { b: number; e: number; k: string[]; } | { b: number; f: number; k: string[]; } | { b: number; g: number; k: string[]; } | { b: number; h: number; k: string[]; } | { b: number; i: number; k: string[]; } | { b: number; j: number; k: string[]; } | { c: number; d: number; k: string[]; } | { c: number; e: number; k: string[]; } | { c: number; f: number; k: string[]; } | { c: number; g: number; k: string[]; } | { c: number; h: number; k: string[]; } | { c: number; i: number; k: string[]; } | { c: number; j: number; k: string[]; } | { d: number; e: number; k: string[]; } | { d: number; f: number; k: string[]; } | { d: number; g: number; k: string[]; } | { d: number; h: number; k: string[]; } | { d: number; i: number; k: string[]; } | { d: number; j: number; k: string[]; } | { e: number; f: number; k: string[]; } | { e: number; g: number; k: string[]; } | { e: number; h: number; k: string[]; } | { e: number; i: number; k: string[]; } | { e: number; j: number; k: string[]; } | { f: number; g: number; k: string[]; } | { f: number; h: number; k: string[]; } | { f: number; i: number; k: string[]; } | { f: number; j: number; k: string[]; } | { g: number; h: number; k: string[]; } | { g: number; i: number; k: string[]; } | { g: number; j: number; k: string[]; } | { h: number; i: number; k: string[]; } | { h: number; j: number; k: string[]; } | { i: number; j: number; k: string[]; } >step.settings.input : { a: number; } | { b: number; } | { c: number; } | { d: number; } | { e: number; } | { f: number; } | { g: number; } | { h: number; } | { i: number; } | { j: number; } | { k?: string[]; } | ({ a: number; } & { b: number; }) | ({ a: number; } & { c: number; }) | ({ a: number; } & { d: number; }) | ({ a: number; } & { e: number; }) | ({ a: number; } & { f: number; }) | ({ a: number; } & { g: number; }) | ({ a: number; } & { h: number; }) | ({ a: number; } & { i: number; }) | ({ a: number; } & { j: number; }) | ({ a: number; } & { k?: string[]; }) | ({ b: number; } & { a: number; }) | ({ b: number; } & { c: number; }) | ({ b: number; } & { d: number; }) | ({ b: number; } & { e: number; }) | ({ b: number; } & { f: number; }) | ({ b: number; } & { g: number; }) | ({ b: number; } & { h: number; }) | ({ b: number; } & { i: number; }) | ({ b: number; } & { j: number; }) | ({ b: number; } & { k?: string[]; }) | ({ c: number; } & { a: number; }) | ({ c: number; } & { b: number; }) | ({ c: number; } & { d: number; }) | ({ c: number; } & { e: number; }) | ({ c: number; } & { f: number; }) | ({ c: number; } & { g: number; }) | ({ c: number; } & { h: number; }) | ({ c: number; } & { i: number; }) | ({ c: number; } & { j: number; }) | ({ c: number; } & { k?: string[]; }) | ({ d: number; } & { a: number; }) | ({ d: number; } & { b: number; }) | ({ d: number; } & { c: number; }) | ({ d: number; } & { e: number; }) | ({ d: number; } & { f: number; }) | ({ d: number; } & { g: number; }) | ({ d: number; } & { h: number; }) | ({ d: number; } & { i: number; }) | ({ d: number; } & { j: number; }) | ({ d: number; } & { k?: string[]; }) | ({ e: number; } & { a: number; }) | ({ e: number; } & { b: number; }) | ({ e: number; } & { c: number; }) | ({ e: number; } & { d: number; }) | ({ e: number; } & { f: number; }) | ({ e: number; } & { g: number; }) | ({ e: number; } & { h: number; }) | ({ e: number; } & { i: number; }) | ({ e: number; } & { j: number; }) | ({ e: number; } & { k?: string[]; }) | ({ f: number; } & { a: number; }) | ({ f: number; } & { b: number; }) | ({ f: number; } & { c: number; }) | ({ f: number; } & { d: number; }) | ({ f: number; } & { e: number; }) | ({ f: number; } & { g: number; }) | ({ f: number; } & { h: number; }) | ({ f: number; } & { i: number; }) | ({ f: number; } & { j: number; }) | ({ f: number; } & { k?: string[]; }) | ({ g: number; } & { a: number; }) | ({ g: number; } & { b: number; }) | ({ g: number; } & { c: number; }) | ({ g: number; } & { d: number; }) | ({ g: number; } & { e: number; }) | ({ g: number; } & { f: number; }) | ({ g: number; } & { h: number; }) | ({ g: number; } & { i: number; }) | ({ g: number; } & { j: number; }) | ({ g: number; } & { k?: string[]; }) | ({ h: number; } & { a: number; }) | ({ h: number; } & { b: number; }) | ({ h: number; } & { c: number; }) | ({ h: number; } & { d: number; }) | ({ h: number; } & { e: number; }) | ({ h: number; } & { f: number; }) | ({ h: number; } & { g: number; }) | ({ h: number; } & { i: number; }) | ({ h: number; } & { j: number; }) | ({ h: number; } & { k?: string[]; }) | ({ i: number; } & { a: number; }) | ({ i: number; } & { b: number; }) | ({ i: number; } & { c: number; }) | ({ i: number; } & { d: number; }) | ({ i: number; } & { e: number; }) | ({ i: number; } & { f: number; }) | ({ i: number; } & { g: number; }) | ({ i: number; } & { h: number; }) | ({ i: number; } & { j: number; }) | ({ i: number; } & { k?: string[]; }) | ({ j: number; } & { a: number; }) | ({ j: number; } & { b: number; }) | ({ j: number; } & { c: number; }) | ({ j: number; } & { d: number; }) | ({ j: number; } & { e: number; }) | ({ j: number; } & { f: number; }) | ({ j: number; } & { g: number; }) | ({ j: number; } & { h: number; }) | ({ j: number; } & { i: number; }) | ({ j: number; } & { k?: string[]; }) | ({ k?: string[]; } & { a: number; }) | ({ k?: string[]; } & { b: number; }) | ({ k?: string[]; } & { c: number; }) | ({ k?: string[]; } & { d: number; }) | ({ k?: string[]; } & { e: number; }) | ({ k?: string[]; } & { f: number; }) | ({ k?: string[]; } & { g: number; }) | ({ k?: string[]; } & { h: number; }) | ({ k?: string[]; } & { i: number; }) | ({ k?: string[]; } & { j: number; }) >step.settings : ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S1) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S10) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S11) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S2) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S3) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S4) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S5) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S6) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S7) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S8) | ((S1 | S10 | S11 | S2 | S3 | S4 | S5 | S6 | S7 | S8 | S9) & S9) >step : Action diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.js index 2413425ee0027..613464e8a9ce9 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.js @@ -78,5 +78,7 @@ export declare const obsA: { v: 0; }; export declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.types index 6e3734d808ac2..d2fb088ff22ab 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExportEqualsQualifiedNameOrder.types @@ -22,8 +22,8 @@ export const obsA = expand(); >oxa : O export const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.js index b04d7f8d88c86..06233f3cd3615 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.js @@ -77,5 +77,7 @@ export declare const obsA: { v: 0; }; export declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.types index 351c0f5869478..236cd6a2af6c0 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitExternalModuleContainerIndexOrder.types @@ -26,8 +26,8 @@ export const obsA = expand(); >expand : () => { [K in keyof X]: X[K]; } export const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } === /ambient.d.ts === diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.js index da41b8a0dc439..09f23b9e441c9 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.js @@ -90,6 +90,8 @@ export declare const obsA: { v: 0; }; export declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; export {}; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.types index 9ca145132f072..a3e841f76db76 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitLateBoundIndexSignatureSiblingsOrder.types @@ -82,8 +82,8 @@ export const obsA = expand(); >oxa : O export const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.js index ea5bdabd550b2..593f5c6192e79 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.js @@ -75,5 +75,7 @@ export declare const obsA: { v: 0; }; export declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.types index ad400806b641d..59c394c4943b9 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitRenamedExportOrder.types @@ -21,8 +21,8 @@ export const obsA = expand(); >oxa : O export const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.js index f297255bfad65..0cd47efb71bf9 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.js @@ -139,5 +139,7 @@ declare const obsA: { v: 0; }; declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.types index cb6e79ef1518c..64131b7405d04 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitUmdGlobalAliasesOrder.types @@ -34,8 +34,8 @@ const obsA = expand(); >oxa : O const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.js index 30a76df171c66..b4b3b1191b09c 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.js @@ -55,5 +55,7 @@ export declare const obsA: { v: 0; }; export declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.types index 2e41e20ad32be..74c433948a034 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitVariableMatchesInScopeOrder.types @@ -19,8 +19,8 @@ export const obsA = expand(); >oxa : O export const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.errors.txt index a2ecba905fe18..62a7166294745 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.errors.txt @@ -1,5 +1,5 @@ /main.ts(7,14): error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. -/main.ts(8,14): error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +/main.ts(8,14): error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /main.ts (2 errors) ==== @@ -14,7 +14,7 @@ !!! error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. export const obsB: never = expand(); ~~~~ -!!! error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +!!! error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /ambient.d.ts (0 errors) ==== declare module "ma" { diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.types index 925b972b915c6..b42d11f662f49 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarCollisionOrder.types @@ -26,7 +26,7 @@ export const obsA: never = expand(); export const obsB: never = expand(); >obsB : never ->expand() : { v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.errors.txt index a05bda29acf17..45ba492a4b355 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.errors.txt @@ -1,5 +1,5 @@ /main.ts(7,14): error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. -/main.ts(8,14): error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +/main.ts(8,14): error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /main.ts (2 errors) ==== @@ -14,7 +14,7 @@ !!! error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. export const obsB: never = expand(); ~~~~ -!!! error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +!!! error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /ambient.d.ts (0 errors) ==== declare module "ma" { diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.types index 58541f8aa49ff..101b6db6c4dee 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsExportStarDeclarationCollisionOrder.types @@ -26,7 +26,7 @@ export const obsA: never = expand(); export const obsB: never = expand(); >obsB : never ->expand() : { v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.errors.txt index fb286e6d925c7..a15ea5b841fce 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.errors.txt @@ -1,4 +1,4 @@ -/main.ts(8,32): error TS2339: Property 'ma' does not exist on type '{}'. +/main.ts(7,32): error TS2339: Property 'mb' does not exist on type '{}'. ==== /main.ts (1 errors) ==== @@ -9,9 +9,9 @@ export const fromA = MA.pa; export const fromB = MB.pb; export const checkA: 1 = MA.pa.mb; - export const checkB: 1 = MB.pb.ma; ~~ -!!! error TS2339: Property 'ma' does not exist on type '{}'. +!!! error TS2339: Property 'mb' does not exist on type '{}'. + export const checkB: 1 = MB.pb.ma; ==== /ma.js (0 errors) ==== export { v as pa } from "./xa"; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.js index 85b0024d3067d..4881af4a1d031 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.js @@ -163,7 +163,10 @@ exports.checkB = MB.pb.ma; //// [xb.d.ts] export = o; declare const o: { - v: {}; + v: { + pa: {}; + ma: 1; + }; }; //// [mb.d.ts] export { v as pb } from "./xb"; @@ -171,10 +174,7 @@ export declare const mb = 1; //// [xa.d.ts] export = o; declare const o: { - v: { - pb: {}; - mb: 1; - }; + v: {}; }; //// [ma.d.ts] export { v as pa } from "./xa"; @@ -183,10 +183,7 @@ export declare const ma = 1; export = o; declare const o: { v: { - pa: { - pb: {}; - mb: 1; - }; + pa: {}; ma: 1; }; }; @@ -194,7 +191,10 @@ declare const o: { export = o; declare const o: { v: { - pb: {}; + pb: { + pa: {}; + ma: 1; + }; mb: 1; }; }; @@ -212,10 +212,10 @@ export declare const f8 = 8; export declare const f9 = 9; export declare const f10 = 10; //// [main.d.ts] -export declare const fromA: { - pb: {}; - mb: 1; +export declare const fromA: {}; +export declare const fromB: { + pa: {}; + ma: 1; }; -export declare const fromB: {}; export declare const checkA: 1; export declare const checkB: 1; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.symbols b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.symbols index aaa25b0469d2f..74e3cd92e4248 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.symbols +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.symbols @@ -28,17 +28,17 @@ export const fromB = MB.pb; export const checkA: 1 = MA.pa.mb; >checkA : Symbol(checkA, Decl(main.ts, 6, 12)) ->MA.pa.mb : Symbol(mb, Decl(mb.js, 1, 12)) >MA.pa : Symbol(MA.pa, Decl(ma.js, 0, 8)) >MA : Symbol(MA, Decl(main.ts, 2, 6)) >pa : Symbol(MA.pa, Decl(ma.js, 0, 8)) ->mb : Symbol(mb, Decl(mb.js, 1, 12)) export const checkB: 1 = MB.pb.ma; >checkB : Symbol(checkB, Decl(main.ts, 7, 12)) +>MB.pb.ma : Symbol(ma, Decl(ma.js, 1, 12)) >MB.pb : Symbol(MB.pb, Decl(mb.js, 0, 8)) >MB : Symbol(MB, Decl(main.ts, 3, 6)) >pb : Symbol(MB.pb, Decl(mb.js, 0, 8)) +>ma : Symbol(ma, Decl(ma.js, 1, 12)) === /ma.js === export { v as pa } from "./xa"; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types index 7813095f076be..f7142131ca798 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types @@ -5,8 +5,8 @@ import * as idx from "./index"; >idx : typeof idx const all = { ...idx }; ->all : { a: { pa: { pb: {}; mb: 1; }; ma: 1; }; b: { pb: {}; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } ->{ ...idx } : { a: { pa: { pb: {}; mb: 1; }; ma: 1; }; b: { pb: {}; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } +>all : { a: { pa: {}; ma: 1; }; b: { pb: { pa: {}; ma: 1; }; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } +>{ ...idx } : { a: { pa: {}; ma: 1; }; b: { pb: { pa: {}; ma: 1; }; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } >idx : typeof idx import * as MA from "./ma"; @@ -16,37 +16,37 @@ import * as MB from "./mb"; >MB : typeof MB export const fromA = MA.pa; ->fromA : { pb: {}; mb: 1; } ->MA.pa : { pb: {}; mb: 1; } +>fromA : {} +>MA.pa : {} >MA : typeof MA ->pa : { pb: {}; mb: 1; } +>pa : {} export const fromB = MB.pb; ->fromB : {} ->MB.pb : {} +>fromB : { pa: {}; ma: 1; } +>MB.pb : { pa: {}; ma: 1; } >MB : typeof MB ->pb : {} +>pb : { pa: {}; ma: 1; } export const checkA: 1 = MA.pa.mb; >checkA : 1 ->MA.pa.mb : 1 ->MA.pa : { pb: {}; mb: 1; } +>MA.pa.mb : any +>MA.pa : {} >MA : typeof MA ->pa : { pb: {}; mb: 1; } ->mb : 1 +>pa : {} +>mb : any export const checkB: 1 = MB.pb.ma; >checkB : 1 ->MB.pb.ma : any ->MB.pb : {} +>MB.pb.ma : 1 +>MB.pb : { pa: {}; ma: 1; } >MB : typeof MB ->pb : {} ->ma : any +>pb : { pa: {}; ma: 1; } +>ma : 1 === /ma.js === export { v as pa } from "./xa"; ->v : { pb: {}; mb: 1; } ->pa : { pb: {}; mb: 1; } +>v : {} +>pa : {} export const ma = 1; >ma : 1 @@ -54,8 +54,8 @@ export const ma = 1; === /mb.js === export { v as pb } from "./xb"; ->v : {} ->pb : {} +>v : { pa: {}; ma: 1; } +>pb : { pa: {}; ma: 1; } export const mb = 1; >mb : 1 @@ -68,18 +68,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>o : { v: {}; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } >M : typeof import("./mb") module.exports = o; ->module.exports = o : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->o : { v: { pb: {}; mb: 1; }; } +>module.exports = o : { v: {}; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { v: {}; } +>o : { v: {}; } === /xb.js === /** @type {typeof import("./ma")} */ @@ -88,18 +88,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: {}; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>o : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } >M : typeof import("./ma") module.exports = o; ->module.exports = o : { v: {}; } ->module.exports : { v: {}; } ->module : { exports: { v: {}; }; } ->exports : { v: {}; } ->o : { v: {}; } +>module.exports = o : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>o : { v: { pa: {}; ma: 1; }; } === /ia.js === /** @type {typeof import("./ma")} */ @@ -108,18 +108,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>o : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } >M : typeof import("./ma") module.exports = o; ->module.exports = o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->module.exports : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->module : { exports: { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; }; } ->exports : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports = o : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>o : { v: { pa: {}; ma: 1; }; } === /ib.js === /** @type {typeof import("./mb")} */ @@ -128,27 +128,27 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } >M : typeof import("./mb") module.exports = o; ->module.exports = o : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->o : { v: { pb: {}; mb: 1; }; } +>module.exports = o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module.exports : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module : { exports: { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; }; } +>exports : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } === /index.js === export { v as a } from "./ia"; ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->a : { pa: { pb: {}; mb: 1; }; ma: 1; } +>v : { pa: {}; ma: 1; } +>a : { pa: {}; ma: 1; } export { v as b } from "./ib"; ->v : { pb: {}; mb: 1; } ->b : { pb: {}; mb: 1; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>b : { pb: { pa: {}; ma: 1; }; mb: 1; } export const f1 = 1; >f1 : 1 diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.errors.txt b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.errors.txt index 408176b1c59d1..c3d47c451cd56 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.errors.txt @@ -1,4 +1,4 @@ -/main.ts(8,32): error TS2339: Property 'ma' does not exist on type '{}'. +/main.ts(7,32): error TS2339: Property 'mb' does not exist on type '{}'. ==== /main.ts (1 errors) ==== @@ -9,9 +9,9 @@ export const fromA = MA.pa; export const fromB = MB.pb; export const checkA: 1 = MA.pa.mb; - export const checkB: 1 = MB.pb.ma; ~~ -!!! error TS2339: Property 'ma' does not exist on type '{}'. +!!! error TS2339: Property 'mb' does not exist on type '{}'. + export const checkB: 1 = MB.pb.ma; ==== /ma.js (0 errors) ==== export { v as pa } from "./xa"; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.js b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.js index beb6f57cf711b..78caebf29bfbb 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.js @@ -161,7 +161,10 @@ exports.checkB = MB.pb.ma; //// [xb.d.ts] export = o; declare const o: { - v: {}; + v: { + pa: {}; + ma: 1; + }; }; //// [mb.d.ts] export { v as pb } from "./xb"; @@ -169,10 +172,7 @@ export declare const mb = 1; //// [xa.d.ts] export = o; declare const o: { - v: { - pb: {}; - mb: 1; - }; + v: {}; }; //// [ma.d.ts] export { v as pa } from "./xa"; @@ -181,10 +181,7 @@ export declare const ma = 1; export = o; declare const o: { v: { - pa: { - pb: {}; - mb: 1; - }; + pa: {}; ma: 1; }; }; @@ -192,15 +189,18 @@ declare const o: { export = o; declare const o: { v: { - pb: {}; + pb: { + pa: {}; + ma: 1; + }; mb: 1; }; }; //// [main.d.ts] -export declare const fromA: { - pb: {}; - mb: 1; +export declare const fromA: {}; +export declare const fromB: { + pa: {}; + ma: 1; }; -export declare const fromB: {}; export declare const checkA: 1; export declare const checkB: 1; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.symbols b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.symbols index e737ff2cbfb8a..5d199dbcf8abb 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.symbols +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.symbols @@ -28,17 +28,17 @@ export const fromB = MB.pb; export const checkA: 1 = MA.pa.mb; >checkA : Symbol(checkA, Decl(main.ts, 6, 12)) ->MA.pa.mb : Symbol(mb, Decl(mb.js, 1, 12)) >MA.pa : Symbol(MA.pa, Decl(ma.js, 0, 8)) >MA : Symbol(MA, Decl(main.ts, 2, 6)) >pa : Symbol(MA.pa, Decl(ma.js, 0, 8)) ->mb : Symbol(mb, Decl(mb.js, 1, 12)) export const checkB: 1 = MB.pb.ma; >checkB : Symbol(checkB, Decl(main.ts, 7, 12)) +>MB.pb.ma : Symbol(ma, Decl(ma.js, 1, 12)) >MB.pb : Symbol(MB.pb, Decl(mb.js, 0, 8)) >MB : Symbol(MB, Decl(main.ts, 3, 6)) >pb : Symbol(MB.pb, Decl(mb.js, 0, 8)) +>ma : Symbol(ma, Decl(ma.js, 1, 12)) === /ma.js === export { v as pa } from "./xa"; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types index acecbd2516c82..7354cbcd52d6f 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types @@ -5,8 +5,8 @@ import * as idx from "./d"; >idx : typeof idx const all = { ...idx }; ->all : { a: { pa: { pb: {}; mb: 1; }; ma: 1; }; b: { pb: {}; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } ->{ ...idx } : { a: { pa: { pb: {}; mb: 1; }; ma: 1; }; b: { pb: {}; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } +>all : { a: { pa: {}; ma: 1; }; b: { pb: { pa: {}; ma: 1; }; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } +>{ ...idx } : { a: { pa: {}; ma: 1; }; b: { pb: { pa: {}; ma: 1; }; mb: 1; }; f1: 1; f2: 2; f3: 3; f4: 4; f5: 5; f6: 6; f7: 7; f8: 8; f9: 9; f10: 10; } >idx : typeof idx import * as MA from "./ma"; @@ -16,37 +16,37 @@ import * as MB from "./mb"; >MB : typeof MB export const fromA = MA.pa; ->fromA : { pb: {}; mb: 1; } ->MA.pa : { pb: {}; mb: 1; } +>fromA : {} +>MA.pa : {} >MA : typeof MA ->pa : { pb: {}; mb: 1; } +>pa : {} export const fromB = MB.pb; ->fromB : {} ->MB.pb : {} +>fromB : { pa: {}; ma: 1; } +>MB.pb : { pa: {}; ma: 1; } >MB : typeof MB ->pb : {} +>pb : { pa: {}; ma: 1; } export const checkA: 1 = MA.pa.mb; >checkA : 1 ->MA.pa.mb : 1 ->MA.pa : { pb: {}; mb: 1; } +>MA.pa.mb : any +>MA.pa : {} >MA : typeof MA ->pa : { pb: {}; mb: 1; } ->mb : 1 +>pa : {} +>mb : any export const checkB: 1 = MB.pb.ma; >checkB : 1 ->MB.pb.ma : any ->MB.pb : {} +>MB.pb.ma : 1 +>MB.pb : { pa: {}; ma: 1; } >MB : typeof MB ->pb : {} ->ma : any +>pb : { pa: {}; ma: 1; } +>ma : 1 === /ma.js === export { v as pa } from "./xa"; ->v : { pb: {}; mb: 1; } ->pa : { pb: {}; mb: 1; } +>v : {} +>pa : {} export const ma = 1; >ma : 1 @@ -54,8 +54,8 @@ export const ma = 1; === /mb.js === export { v as pb } from "./xb"; ->v : {} ->pb : {} +>v : { pa: {}; ma: 1; } +>pb : { pa: {}; ma: 1; } export const mb = 1; >mb : 1 @@ -68,18 +68,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>o : { v: {}; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } >M : typeof import("./mb") module.exports = o; ->module.exports = o : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->o : { v: { pb: {}; mb: 1; }; } +>module.exports = o : { v: {}; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { v: {}; } +>o : { v: {}; } === /xb.js === /** @type {typeof import("./ma")} */ @@ -88,18 +88,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: {}; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>o : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } >M : typeof import("./ma") module.exports = o; ->module.exports = o : { v: {}; } ->module.exports : { v: {}; } ->module : { exports: { v: {}; }; } ->exports : { v: {}; } ->o : { v: {}; } +>module.exports = o : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>o : { v: { pa: {}; ma: 1; }; } === /ia.js === /** @type {typeof import("./ma")} */ @@ -108,18 +108,18 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>o : { v: { pa: {}; ma: 1; }; } +>{ v: { ...M } } : { v: { pa: {}; ma: 1; }; } +>v : { pa: {}; ma: 1; } +>{ ...M } : { pa: {}; ma: 1; } >M : typeof import("./ma") module.exports = o; ->module.exports = o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->module.exports : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->module : { exports: { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; }; } ->exports : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->o : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports = o : { v: { pa: {}; ma: 1; }; } +>module.exports : { v: { pa: {}; ma: 1; }; } +>module : { exports: { v: { pa: {}; ma: 1; }; }; } +>exports : { v: { pa: {}; ma: 1; }; } +>o : { v: { pa: {}; ma: 1; }; } === /ib.js === /** @type {typeof import("./mb")} */ @@ -128,41 +128,41 @@ const M = /** @type {any} */ (null); >(null) : any const o = { v: { ...M } }; ->o : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>{ ...M } : { pb: { pa: {}; ma: 1; }; mb: 1; } >M : typeof import("./mb") module.exports = o; ->module.exports = o : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->o : { v: { pb: {}; mb: 1; }; } +>module.exports = o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module.exports : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>module : { exports: { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; }; } +>exports : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } +>o : { v: { pb: { pa: {}; ma: 1; }; mb: 1; }; } === /ia2.d.ts === export { v } from "./ia"; ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } +>v : { pa: {}; ma: 1; } export type v = number; >v : number === /ib2.d.ts === export { v } from "./ib"; ->v : { pb: {}; mb: 1; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } export type v = number; >v : number === /index.d.ts === export { v as a } from "./ia2"; ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->a : { pa: { pb: {}; mb: 1; }; ma: 1; } +>v : { pa: {}; ma: 1; } +>a : { pa: {}; ma: 1; } export { v as b } from "./ib2"; ->v : { pb: {}; mb: 1; } ->b : { pb: {}; mb: 1; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>b : { pb: { pa: {}; ma: 1; }; mb: 1; } export const f1: 1; >f1 : 1 @@ -196,12 +196,12 @@ export const f10: 10; === /index2.d.ts === export { v as a } from "./ia2"; ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->a : { pa: { pb: {}; mb: 1; }; ma: 1; } +>v : { pa: {}; ma: 1; } +>a : { pa: {}; ma: 1; } export { v as b } from "./ib2"; ->v : { pb: {}; mb: 1; } ->b : { pb: {}; mb: 1; } +>v : { pb: { pa: {}; ma: 1; }; mb: 1; } +>b : { pb: { pa: {}; ma: 1; }; mb: 1; } === /d.d.ts === diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.errors.txt index aba9bd814f87b..9d0c5d89f5be4 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.errors.txt @@ -1,6 +1,6 @@ /main.ts(2,10): error TS2459: Module '"mt"' declares 'zz' locally, but it is not exported. /main.ts(6,14): error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. -/main.ts(7,14): error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +/main.ts(7,14): error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /main.ts (3 errors) ==== @@ -17,7 +17,7 @@ !!! error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. export const obsB: never = expand(); ~~~~ -!!! error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +!!! error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /ambient.d.ts (0 errors) ==== declare module "ma" { diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.types index 00ba3854da277..ce4272bde5283 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNonExportedMemberOrder.types @@ -22,7 +22,7 @@ export const obsA: never = expand(); export const obsB: never = expand(); >obsB : never ->expand() : { v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.errors.txt index d8667784e78ea..a0a32ab10d645 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.errors.txt @@ -1,6 +1,6 @@ /main.ts(17,11): error TS2304: Cannot find name 'zz'. /main.ts(18,7): error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. -/main.ts(19,7): error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +/main.ts(19,7): error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /main.ts (3 errors) ==== @@ -28,7 +28,7 @@ !!! error TS2322: Type '{ pb: 0; readonly mb: 1; v: 0; }' is not assignable to type 'never'. const obsB: never = expand(); ~~~~ -!!! error TS2322: Type '{ v: 0; }' is not assignable to type 'never'. +!!! error TS2322: Type '{ pa: 0; readonly ma: 1; v: 0; }' is not assignable to type 'never'. ==== /ambient.d.ts (0 errors) ==== declare module "ma" { diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.types index 0c8a7c9521634..68af529e6dd8b 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsSpellingSuggestionOrder.types @@ -35,7 +35,7 @@ const obsA: never = expand(); const obsB: never = expand(); >obsB : never ->expand() : { v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.errors.txt index d81eb346f2055..c291bb9504fc7 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.errors.txt @@ -1,8 +1,7 @@ /mm.ts(5,1): error TS2309: An export assignment cannot be used in a module with other exported elements. -/mm.ts(19,30): error TS2339: Property 'pa' does not exist on type 'O'. -==== /mm.ts (2 errors) ==== +==== /mm.ts (1 errors) ==== /// declare const oxa: typeof import("xa"); declare const oxb: typeof import("xb"); @@ -24,8 +23,6 @@ export interface F10 {} export const checkA: 0 = oxa.pb; export const checkB: 0 = oxb.pa; - ~~ -!!! error TS2339: Property 'pa' does not exist on type 'O'. ==== /ambient.d.ts (0 errors) ==== declare module "ma" { diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.symbols b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.symbols index 74a9fa86901eb..dc3daa982e602 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.symbols +++ b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.symbols @@ -61,7 +61,9 @@ export const checkA: 0 = oxa.pb; export const checkB: 0 = oxb.pa; >checkB : Symbol(checkB, Decl(mm.ts, 18, 12)) +>oxb.pa : Symbol(pa, Decl(ambient.d.ts, 1, 12)) >oxb : Symbol(oxb, Decl(mm.ts, 2, 13)) +>pa : Symbol(pa, Decl(ambient.d.ts, 1, 12)) === /ambient.d.ts === declare module "ma" { diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.types index 44664dcadfb80..d50ab18d6826e 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsCheckOrder.types @@ -41,9 +41,9 @@ export const checkA: 0 = oxa.pb; export const checkB: 0 = oxb.pa; >checkB : 0 ->oxb.pa : any +>oxb.pa : 0 >oxb : O ->pa : any +>pa : 0 === /ambient.d.ts === declare module "ma" { diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.js b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.js index 37e7a9ff94890..527e0cf1c555a 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.js +++ b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.js @@ -71,5 +71,7 @@ export declare const obsA: { v: 0; }; export declare const obsB: { + pa: 0; + readonly ma: 1; v: 0; }; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.types index c0ba114c78355..03579880e27c4 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyExportEqualsWithOtherExportsImportOrder.types @@ -25,8 +25,8 @@ export const obsA = expand(); >oxa : O export const obsB = expand(); ->obsB : { v: 0; } ->expand() : { v: 0; } +>obsB : { pa: 0; readonly ma: 1; v: 0; } +>expand() : { pa: 0; readonly ma: 1; v: 0; } >expand : () => { [K in keyof X]: X[K]; } >oxb : O diff --git a/tsc/testdata/baselines/reference/compiler/noImplicitAnyUnionNormalizedObjectLiteral1.types b/tsc/testdata/baselines/reference/compiler/noImplicitAnyUnionNormalizedObjectLiteral1.types index ecefa9258056c..c25988851e359 100644 --- a/tsc/testdata/baselines/reference/compiler/noImplicitAnyUnionNormalizedObjectLiteral1.types +++ b/tsc/testdata/baselines/reference/compiler/noImplicitAnyUnionNormalizedObjectLiteral1.types @@ -36,8 +36,8 @@ function doSthWithParams(params: unknown) { } const bar = { ->bar : { c?: undefined; p: any; s: any; } | { c: string; p: string; s: string; } ->{ p: null, s: null, ...doSthWithParams({ p: "hello", s: "world", }),} : { c?: undefined; p: null; s: null; } | { c: string; p: string; s: string; } +>bar : { c: string; p: string; s: string; } | { c?: undefined; p: any; s: any; } +>{ p: null, s: null, ...doSthWithParams({ p: "hello", s: "world", }),} : { c: string; p: string; s: string; } | { c?: undefined; p: null; s: null; } p: null, >p : null diff --git a/tsc/testdata/baselines/reference/compiler/objectInstantiationFromUnionSpread.types b/tsc/testdata/baselines/reference/compiler/objectInstantiationFromUnionSpread.types index 25ef32588b01c..5bc7169b9dc27 100644 --- a/tsc/testdata/baselines/reference/compiler/objectInstantiationFromUnionSpread.types +++ b/tsc/testdata/baselines/reference/compiler/objectInstantiationFromUnionSpread.types @@ -23,20 +23,20 @@ function f1(a: Item[]) { >a : Item[] a.map(item => ({ ...item })).filter(value => {}); ->a.map(item => ({ ...item })).filter(value => {}) : ({ isSuccess: false; } | { isSuccess: true; })[] ->a.map(item => ({ ...item })).filter : { (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => unknown, thisArg?: any): ({ isSuccess: false; } | { isSuccess: true; })[]; } ->a.map(item => ({ ...item })) : ({ isSuccess: false; } | { isSuccess: true; })[] +>a.map(item => ({ ...item })).filter(value => {}) : ({ isSuccess: true; } | { isSuccess: false; })[] +>a.map(item => ({ ...item })).filter : { (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; } +>a.map(item => ({ ...item })) : ({ isSuccess: true; } | { isSuccess: false; })[] >a.map : (callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[] >a : Item[] >map : (callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[] ->item => ({ ...item }) : (item: Item) => { isSuccess: false; } | { isSuccess: true; } +>item => ({ ...item }) : (item: Item) => { isSuccess: true; } | { isSuccess: false; } >item : Item ->({ ...item }) : { isSuccess: false; } | { isSuccess: true; } ->{ ...item } : { isSuccess: false; } | { isSuccess: true; } +>({ ...item }) : { isSuccess: true; } | { isSuccess: false; } +>{ ...item } : { isSuccess: true; } | { isSuccess: false; } >item : Item ->filter : { (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => unknown, thisArg?: any): ({ isSuccess: false; } | { isSuccess: true; })[]; } ->value => {} : (value: { isSuccess: false; } | { isSuccess: true; }) => void ->value : { isSuccess: false; } | { isSuccess: true; } +>filter : { (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; } +>value => {} : (value: { isSuccess: true; } | { isSuccess: false; }) => void +>value : { isSuccess: true; } | { isSuccess: false; } } function f2(a: Item[]) { @@ -44,19 +44,19 @@ function f2(a: Item[]) { >a : Item[] a.map(item => ({ ...item })).filter(value => {}); ->a.map(item => ({ ...item })).filter(value => {}) : ({ isSuccess: false; } | { isSuccess: true; })[] ->a.map(item => ({ ...item })).filter : { (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => unknown, thisArg?: any): ({ isSuccess: false; } | { isSuccess: true; })[]; } ->a.map(item => ({ ...item })) : ({ isSuccess: false; } | { isSuccess: true; })[] +>a.map(item => ({ ...item })).filter(value => {}) : ({ isSuccess: true; } | { isSuccess: false; })[] +>a.map(item => ({ ...item })).filter : { (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; } +>a.map(item => ({ ...item })) : ({ isSuccess: true; } | { isSuccess: false; })[] >a.map : (callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[] >a : Item[] >map : (callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[] ->item => ({ ...item }) : (item: Item) => { isSuccess: false; } | { isSuccess: true; } +>item => ({ ...item }) : (item: Item) => { isSuccess: true; } | { isSuccess: false; } >item : Item ->({ ...item }) : { isSuccess: false; } | { isSuccess: true; } ->{ ...item } : { isSuccess: false; } | { isSuccess: true; } +>({ ...item }) : { isSuccess: true; } | { isSuccess: false; } +>{ ...item } : { isSuccess: true; } | { isSuccess: false; } >item : Item ->filter : { (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: false; } | { isSuccess: true; }, index: number, array: ({ isSuccess: false; } | { isSuccess: true; })[]) => unknown, thisArg?: any): ({ isSuccess: false; } | { isSuccess: true; })[]; } ->value => {} : (value: { isSuccess: false; } | { isSuccess: true; }) => void ->value : { isSuccess: false; } | { isSuccess: true; } +>filter : { (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; } +>value => {} : (value: { isSuccess: true; } | { isSuccess: false; }) => void +>value : { isSuccess: true; } | { isSuccess: false; } } diff --git a/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).js new file mode 100644 index 0000000000000..c4a71d9b83c23 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts] //// + +//// [objectLiteralRegularAndWidenedCopyOrder.ts] +declare const b: boolean; +let x; +x = { a: 1 }; +let arr = []; +arr.push(x); // regular copy of the literal +const y = x; // widened copy of the literal +const z = b ? (b ? arr[0] : y) : { c: 1 }; + + +//// [objectLiteralRegularAndWidenedCopyOrder.js] +"use strict"; +let x; +x = { a: 1 }; +let arr = []; +arr.push(x); // regular copy of the literal +const y = x; // widened copy of the literal +const z = b ? (b ? arr[0] : y) : { c: 1 }; diff --git a/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..4ff568c410bfc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts] //// + +=== objectLiteralRegularAndWidenedCopyOrder.ts === +declare const b: boolean; +>b : Symbol(b, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 0, 13)) + +let x; +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) + +x = { a: 1 }; +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) +>a : Symbol(a, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 2, 5)) + +let arr = []; +>arr : Symbol(arr, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 3, 3)) + +arr.push(x); // regular copy of the literal +>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>arr : Symbol(arr, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 3, 3)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) + +const y = x; // widened copy of the literal +>y : Symbol(y, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 5, 5)) +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) + +const z = b ? (b ? arr[0] : y) : { c: 1 }; +>z : Symbol(z, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 6, 5)) +>b : Symbol(b, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 0, 13)) +>b : Symbol(b, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 0, 13)) +>arr : Symbol(arr, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 3, 3)) +>y : Symbol(y, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 5, 5)) +>c : Symbol(c, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 6, 34)) + diff --git a/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).types new file mode 100644 index 0000000000000..c357eab575d5b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).types @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts] //// + +=== objectLiteralRegularAndWidenedCopyOrder.ts === +declare const b: boolean; +>b : boolean + +let x; +>x : any + +x = { a: 1 }; +>x = { a: 1 } : { a: number; } +>x : any +>{ a: 1 } : { a: number; } +>a : number +>1 : 1 + +let arr = []; +>arr : any[] +>[] : never[] + +arr.push(x); // regular copy of the literal +>arr.push(x) : number +>arr.push : (...items: any[]) => number +>arr : any[] +>push : (...items: any[]) => number +>x : { a: number; } + +const y = x; // widened copy of the literal +>y : { a: number; } +>x : { a: number; } + +const z = b ? (b ? arr[0] : y) : { c: 1 }; +>z : { a: number; } | { c: number; } +>b ? (b ? arr[0] : y) : { c: 1 } : { a: number; } | { c: number; } +>b : boolean +>(b ? arr[0] : y) : { a: number; } +>b ? arr[0] : y : { a: number; } +>b : true +>arr[0] : { a: number; } +>arr : { a: number; }[] +>0 : 0 +>y : { a: number; } +>{ c: 1 } : { c: number; } +>c : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..c4a71d9b83c23 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts] //// + +//// [objectLiteralRegularAndWidenedCopyOrder.ts] +declare const b: boolean; +let x; +x = { a: 1 }; +let arr = []; +arr.push(x); // regular copy of the literal +const y = x; // widened copy of the literal +const z = b ? (b ? arr[0] : y) : { c: 1 }; + + +//// [objectLiteralRegularAndWidenedCopyOrder.js] +"use strict"; +let x; +x = { a: 1 }; +let arr = []; +arr.push(x); // regular copy of the literal +const y = x; // widened copy of the literal +const z = b ? (b ? arr[0] : y) : { c: 1 }; diff --git a/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..4ff568c410bfc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts] //// + +=== objectLiteralRegularAndWidenedCopyOrder.ts === +declare const b: boolean; +>b : Symbol(b, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 0, 13)) + +let x; +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) + +x = { a: 1 }; +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) +>a : Symbol(a, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 2, 5)) + +let arr = []; +>arr : Symbol(arr, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 3, 3)) + +arr.push(x); // regular copy of the literal +>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>arr : Symbol(arr, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 3, 3)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) + +const y = x; // widened copy of the literal +>y : Symbol(y, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 5, 5)) +>x : Symbol(x, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 1, 3)) + +const z = b ? (b ? arr[0] : y) : { c: 1 }; +>z : Symbol(z, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 6, 5)) +>b : Symbol(b, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 0, 13)) +>b : Symbol(b, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 0, 13)) +>arr : Symbol(arr, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 3, 3)) +>y : Symbol(y, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 5, 5)) +>c : Symbol(c, Decl(objectLiteralRegularAndWidenedCopyOrder.ts, 6, 34)) + diff --git a/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..c357eab575d5b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).types @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts] //// + +=== objectLiteralRegularAndWidenedCopyOrder.ts === +declare const b: boolean; +>b : boolean + +let x; +>x : any + +x = { a: 1 }; +>x = { a: 1 } : { a: number; } +>x : any +>{ a: 1 } : { a: number; } +>a : number +>1 : 1 + +let arr = []; +>arr : any[] +>[] : never[] + +arr.push(x); // regular copy of the literal +>arr.push(x) : number +>arr.push : (...items: any[]) => number +>arr : any[] +>push : (...items: any[]) => number +>x : { a: number; } + +const y = x; // widened copy of the literal +>y : { a: number; } +>x : { a: number; } + +const z = b ? (b ? arr[0] : y) : { c: 1 }; +>z : { a: number; } | { c: number; } +>b ? (b ? arr[0] : y) : { c: 1 } : { a: number; } | { c: number; } +>b : boolean +>(b ? arr[0] : y) : { a: number; } +>b ? arr[0] : y : { a: number; } +>b : true +>arr[0] : { a: number; } +>arr : { a: number; }[] +>0 : 0 +>y : { a: number; } +>{ c: 1 } : { c: number; } +>c : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..49bd036214070 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).symbols @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/objectRestUnionInstantiationOrder.ts] //// + +=== objectRestUnionInstantiationOrder.ts === +function f(v: { k: "a"; a: T } | { k: "b"; b: number }) { +>f : Symbol(f, Decl(objectRestUnionInstantiationOrder.ts, 0, 0)) +>T : Symbol(T, Decl(objectRestUnionInstantiationOrder.ts, 0, 11)) +>v : Symbol(v, Decl(objectRestUnionInstantiationOrder.ts, 0, 14)) +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 0, 18)) +>a : Symbol(a, Decl(objectRestUnionInstantiationOrder.ts, 0, 26)) +>T : Symbol(T, Decl(objectRestUnionInstantiationOrder.ts, 0, 11)) +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 0, 37)) +>b : Symbol(b, Decl(objectRestUnionInstantiationOrder.ts, 0, 45)) + + const { k, ...rest } = v; +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 1, 11)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>v : Symbol(v, Decl(objectRestUnionInstantiationOrder.ts, 0, 14)) + + return { all: rest, onlyB: "b" in rest ? rest : undefined }; +>all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 2, 12)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 2, 23)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>undefined : Symbol(undefined) +} +const o = f({ k: "a", a: "s" }); +>o : Symbol(o, Decl(objectRestUnionInstantiationOrder.ts, 4, 5)) +>f : Symbol(f, Decl(objectRestUnionInstantiationOrder.ts, 0, 0)) +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 4, 13)) +>a : Symbol(a, Decl(objectRestUnionInstantiationOrder.ts, 4, 21)) + +const all = o.all; +>all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 5, 5)) +>o.all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 2, 12)) +>o : Symbol(o, Decl(objectRestUnionInstantiationOrder.ts, 4, 5)) +>all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 2, 12)) + +const onlyB = o.onlyB; +>onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 6, 5)) +>o.onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 2, 23)) +>o : Symbol(o, Decl(objectRestUnionInstantiationOrder.ts, 4, 5)) +>onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 2, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).types new file mode 100644 index 0000000000000..b0974642e75b9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).types @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/objectRestUnionInstantiationOrder.ts] //// + +=== objectRestUnionInstantiationOrder.ts === +function f(v: { k: "a"; a: T } | { k: "b"; b: number }) { +>f : (v: { k: "a"; a: T; } | { k: "b"; b: number; }) => { all: { a: T; } | { b: number; }; onlyB: { b: number; } | undefined; } +>v : { k: "a"; a: T; } | { k: "b"; b: number; } +>k : "a" +>a : T +>k : "b" +>b : number + + const { k, ...rest } = v; +>k : "a" | "b" +>rest : { a: T; } | { b: number; } +>v : { k: "a"; a: T; } | { k: "b"; b: number; } + + return { all: rest, onlyB: "b" in rest ? rest : undefined }; +>{ all: rest, onlyB: "b" in rest ? rest : undefined } : { all: { a: T; } | { b: number; }; onlyB: { b: number; } | undefined; } +>all : { a: T; } | { b: number; } +>rest : { a: T; } | { b: number; } +>onlyB : { b: number; } | undefined +>"b" in rest ? rest : undefined : { b: number; } | undefined +>"b" in rest : boolean +>"b" : "b" +>rest : { a: T; } | { b: number; } +>rest : { b: number; } +>undefined : undefined +} +const o = f({ k: "a", a: "s" }); +>o : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>f({ k: "a", a: "s" }) : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>f : (v: { k: "a"; a: T; } | { k: "b"; b: number; }) => { all: { a: T; } | { b: number; }; onlyB: { b: number; } | undefined; } +>{ k: "a", a: "s" } : { k: "a"; a: string; } +>k : "a" +>"a" : "a" +>a : string +>"s" : "s" + +const all = o.all; +>all : { a: string; } | { b: number; } +>o.all : { a: string; } | { b: number; } +>o : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>all : { a: string; } | { b: number; } + +const onlyB = o.onlyB; +>onlyB : { b: number; } | undefined +>o.onlyB : { b: number; } | undefined +>o : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>onlyB : { b: number; } | undefined + diff --git a/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..49bd036214070 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).symbols @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/objectRestUnionInstantiationOrder.ts] //// + +=== objectRestUnionInstantiationOrder.ts === +function f(v: { k: "a"; a: T } | { k: "b"; b: number }) { +>f : Symbol(f, Decl(objectRestUnionInstantiationOrder.ts, 0, 0)) +>T : Symbol(T, Decl(objectRestUnionInstantiationOrder.ts, 0, 11)) +>v : Symbol(v, Decl(objectRestUnionInstantiationOrder.ts, 0, 14)) +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 0, 18)) +>a : Symbol(a, Decl(objectRestUnionInstantiationOrder.ts, 0, 26)) +>T : Symbol(T, Decl(objectRestUnionInstantiationOrder.ts, 0, 11)) +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 0, 37)) +>b : Symbol(b, Decl(objectRestUnionInstantiationOrder.ts, 0, 45)) + + const { k, ...rest } = v; +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 1, 11)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>v : Symbol(v, Decl(objectRestUnionInstantiationOrder.ts, 0, 14)) + + return { all: rest, onlyB: "b" in rest ? rest : undefined }; +>all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 2, 12)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 2, 23)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>rest : Symbol(rest, Decl(objectRestUnionInstantiationOrder.ts, 1, 14)) +>undefined : Symbol(undefined) +} +const o = f({ k: "a", a: "s" }); +>o : Symbol(o, Decl(objectRestUnionInstantiationOrder.ts, 4, 5)) +>f : Symbol(f, Decl(objectRestUnionInstantiationOrder.ts, 0, 0)) +>k : Symbol(k, Decl(objectRestUnionInstantiationOrder.ts, 4, 13)) +>a : Symbol(a, Decl(objectRestUnionInstantiationOrder.ts, 4, 21)) + +const all = o.all; +>all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 5, 5)) +>o.all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 2, 12)) +>o : Symbol(o, Decl(objectRestUnionInstantiationOrder.ts, 4, 5)) +>all : Symbol(all, Decl(objectRestUnionInstantiationOrder.ts, 2, 12)) + +const onlyB = o.onlyB; +>onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 6, 5)) +>o.onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 2, 23)) +>o : Symbol(o, Decl(objectRestUnionInstantiationOrder.ts, 4, 5)) +>onlyB : Symbol(onlyB, Decl(objectRestUnionInstantiationOrder.ts, 2, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..b0974642e75b9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/objectRestUnionInstantiationOrder.ts] //// + +=== objectRestUnionInstantiationOrder.ts === +function f(v: { k: "a"; a: T } | { k: "b"; b: number }) { +>f : (v: { k: "a"; a: T; } | { k: "b"; b: number; }) => { all: { a: T; } | { b: number; }; onlyB: { b: number; } | undefined; } +>v : { k: "a"; a: T; } | { k: "b"; b: number; } +>k : "a" +>a : T +>k : "b" +>b : number + + const { k, ...rest } = v; +>k : "a" | "b" +>rest : { a: T; } | { b: number; } +>v : { k: "a"; a: T; } | { k: "b"; b: number; } + + return { all: rest, onlyB: "b" in rest ? rest : undefined }; +>{ all: rest, onlyB: "b" in rest ? rest : undefined } : { all: { a: T; } | { b: number; }; onlyB: { b: number; } | undefined; } +>all : { a: T; } | { b: number; } +>rest : { a: T; } | { b: number; } +>onlyB : { b: number; } | undefined +>"b" in rest ? rest : undefined : { b: number; } | undefined +>"b" in rest : boolean +>"b" : "b" +>rest : { a: T; } | { b: number; } +>rest : { b: number; } +>undefined : undefined +} +const o = f({ k: "a", a: "s" }); +>o : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>f({ k: "a", a: "s" }) : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>f : (v: { k: "a"; a: T; } | { k: "b"; b: number; }) => { all: { a: T; } | { b: number; }; onlyB: { b: number; } | undefined; } +>{ k: "a", a: "s" } : { k: "a"; a: string; } +>k : "a" +>"a" : "a" +>a : string +>"s" : "s" + +const all = o.all; +>all : { a: string; } | { b: number; } +>o.all : { a: string; } | { b: number; } +>o : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>all : { a: string; } | { b: number; } + +const onlyB = o.onlyB; +>onlyB : { b: number; } | undefined +>o.onlyB : { b: number; } | undefined +>o : { all: { a: string; } | { b: number; }; onlyB: { b: number; } | undefined; } +>onlyB : { b: number; } | undefined + diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).errors.txt new file mode 100644 index 0000000000000..47be7df4a2a28 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).errors.txt @@ -0,0 +1,80 @@ +overloadresolutionWithConstraintCheckingDeferred.ts(14,26): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. + Types of parameters 'x' and 'x' are incompatible. + Property 'q' is missing in type 'B' but required in type 'D'. +overloadresolutionWithConstraintCheckingDeferred.ts(14,37): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +overloadresolutionWithConstraintCheckingDeferred.ts(16,27): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. + Types of parameters 'x' and 'x' are incompatible. + Property 'q' is missing in type 'B' but required in type 'D'. +overloadresolutionWithConstraintCheckingDeferred.ts(16,38): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +overloadresolutionWithConstraintCheckingDeferred.ts(18,27): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. + Types of parameters 'x' and 'x' are incompatible. + Property 'q' is missing in type 'B' but required in type 'D'. +overloadresolutionWithConstraintCheckingDeferred.ts(19,14): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +overloadresolutionWithConstraintCheckingDeferred.ts(19,32): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. + + +==== overloadresolutionWithConstraintCheckingDeferred.ts (7 errors) ==== + interface A { x } + interface B { x; y } + interface C { z } + interface D { q } + + class G { + constructor(x: T) { } + } + + declare function foo(arg: (x: D) => number): string; + declare function foo(arg: (x: C) => any): string; + declare function foo(arg: (x: B) => any): number; + + var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + ~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. +!!! error TS2769: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2769: Property 'q' is missing in type 'B' but required in type 'D'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:4:15: 'q' is declared here. +!!! related TS2771 overloadresolutionWithConstraintCheckingDeferred.ts:12:18: The last overload is declared here. + ~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + + var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. +!!! error TS2769: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2769: Property 'q' is missing in type 'B' but required in type 'D'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:4:15: 'q' is declared here. +!!! related TS2771 overloadresolutionWithConstraintCheckingDeferred.ts:12:18: The last overload is declared here. + ~~~~~~~~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + + var result3: string = foo(x => { // x has type D + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. +!!! error TS2769: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2769: Property 'q' is missing in type 'B' but required in type 'D'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:4:15: 'q' is declared here. +!!! related TS2771 overloadresolutionWithConstraintCheckingDeferred.ts:12:18: The last overload is declared here. + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error + ~~~~~~~~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + ~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + return y; + }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).js new file mode 100644 index 0000000000000..bf035f63927a4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).js @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts] //// + +//// [overloadresolutionWithConstraintCheckingDeferred.ts] +interface A { x } +interface B { x; y } +interface C { z } +interface D { q } + +class G { + constructor(x: T) { } +} + +declare function foo(arg: (x: D) => number): string; +declare function foo(arg: (x: C) => any): string; +declare function foo(arg: (x: B) => any): number; + +var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + +var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + +var result3: string = foo(x => { // x has type D + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error + return y; +}); + + +//// [overloadresolutionWithConstraintCheckingDeferred.js] +"use strict"; +class G { + constructor(x) { } +} +var result = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +var result2 = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +var result3 = foo(x => { + var y = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error + return y; +}); diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).symbols new file mode 100644 index 0000000000000..c06f37a086801 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).symbols @@ -0,0 +1,80 @@ +//// [tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts] //// + +=== overloadresolutionWithConstraintCheckingDeferred.ts === +interface A { x } +>A : Symbol(A, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 0)) +>x : Symbol(A.x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 13)) + +interface B { x; y } +>B : Symbol(B, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 17)) +>x : Symbol(B.x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 13)) +>y : Symbol(B.y, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 16)) + +interface C { z } +>C : Symbol(C, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 20)) +>z : Symbol(C.z, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 2, 13)) + +interface D { q } +>D : Symbol(D, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 2, 17)) +>q : Symbol(D.q, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 13)) + +class G { +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>T : Symbol(T, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 5, 8)) +>A : Symbol(A, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 0)) + + constructor(x: T) { } +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 6, 16)) +>T : Symbol(T, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 5, 8)) +} + +declare function foo(arg: (x: D) => number): string; +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>arg : Symbol(arg, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 21)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 27)) +>D : Symbol(D, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 2, 17)) + +declare function foo(arg: (x: C) => any): string; +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>arg : Symbol(arg, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 21)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 27)) +>C : Symbol(C, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 20)) + +declare function foo(arg: (x: B) => any): number; +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>arg : Symbol(arg, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 11, 21)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 11, 27)) +>B : Symbol(B, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 17)) + +var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result : Symbol(result, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 13, 3)) +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 13, 25)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 13, 25)) + +var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result2 : Symbol(result2, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 3)) +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 26)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 26)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 26)) + +var result3: string = foo(x => { // x has type D +>result3 : Symbol(result3, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 3)) +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 26)) + + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error +>y : Symbol(y, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 18, 7)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 26)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 26)) + + return y; +>y : Symbol(y, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 18, 7)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).types new file mode 100644 index 0000000000000..df9ec39e7e837 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).types @@ -0,0 +1,78 @@ +//// [tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts] //// + +=== overloadresolutionWithConstraintCheckingDeferred.ts === +interface A { x } +>x : any + +interface B { x; y } +>x : any +>y : any + +interface C { z } +>z : any + +interface D { q } +>q : any + +class G { +>G : G + + constructor(x: T) { } +>x : T +} + +declare function foo(arg: (x: D) => number): string; +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>arg : (x: D) => number +>x : D + +declare function foo(arg: (x: C) => any): string; +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>arg : (x: C) => any +>x : C + +declare function foo(arg: (x: B) => any): number; +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>arg : (x: B) => any +>x : B + +var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result : number +>foo(x => new G(x)) : never +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>x => new G(x) : (x: D) => G +>x : D +>new G(x) : G +>G : typeof G +>x : D + +var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result2 : number +>foo(x => new G(x)) : never +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>x => new G(x) : (x: D) => G +>x : D +>new G(x) : G +>G : typeof G +>x : D +>x : D + +var result3: string = foo(x => { // x has type D +>result3 : string +>foo(x => { // x has type D var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error return y;}) : never +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>x => { // x has type D var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error return y;} : (x: D) => G +>x : D + + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error +>y : G +>x : D +>new G(x) : G +>G : typeof G +>x : D + + return y; +>y : G + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..47be7df4a2a28 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt @@ -0,0 +1,80 @@ +overloadresolutionWithConstraintCheckingDeferred.ts(14,26): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. + Types of parameters 'x' and 'x' are incompatible. + Property 'q' is missing in type 'B' but required in type 'D'. +overloadresolutionWithConstraintCheckingDeferred.ts(14,37): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +overloadresolutionWithConstraintCheckingDeferred.ts(16,27): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. + Types of parameters 'x' and 'x' are incompatible. + Property 'q' is missing in type 'B' but required in type 'D'. +overloadresolutionWithConstraintCheckingDeferred.ts(16,38): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +overloadresolutionWithConstraintCheckingDeferred.ts(18,27): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. + Types of parameters 'x' and 'x' are incompatible. + Property 'q' is missing in type 'B' but required in type 'D'. +overloadresolutionWithConstraintCheckingDeferred.ts(19,14): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +overloadresolutionWithConstraintCheckingDeferred.ts(19,32): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. + + +==== overloadresolutionWithConstraintCheckingDeferred.ts (7 errors) ==== + interface A { x } + interface B { x; y } + interface C { z } + interface D { q } + + class G { + constructor(x: T) { } + } + + declare function foo(arg: (x: D) => number): string; + declare function foo(arg: (x: C) => any): string; + declare function foo(arg: (x: B) => any): number; + + var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + ~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. +!!! error TS2769: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2769: Property 'q' is missing in type 'B' but required in type 'D'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:4:15: 'q' is declared here. +!!! related TS2771 overloadresolutionWithConstraintCheckingDeferred.ts:12:18: The last overload is declared here. + ~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + + var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. +!!! error TS2769: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2769: Property 'q' is missing in type 'B' but required in type 'D'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:4:15: 'q' is declared here. +!!! related TS2771 overloadresolutionWithConstraintCheckingDeferred.ts:12:18: The last overload is declared here. + ~~~~~~~~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + + var result3: string = foo(x => { // x has type D + ~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '(x: D) => G' is not assignable to parameter of type '(x: B) => any'. +!!! error TS2769: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2769: Property 'q' is missing in type 'B' but required in type 'D'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:4:15: 'q' is declared here. +!!! related TS2771 overloadresolutionWithConstraintCheckingDeferred.ts:12:18: The last overload is declared here. + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error + ~~~~~~~~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + ~ +!!! error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. +!!! related TS2728 overloadresolutionWithConstraintCheckingDeferred.ts:1:15: 'x' is declared here. + return y; + }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).js new file mode 100644 index 0000000000000..bf035f63927a4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).js @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts] //// + +//// [overloadresolutionWithConstraintCheckingDeferred.ts] +interface A { x } +interface B { x; y } +interface C { z } +interface D { q } + +class G { + constructor(x: T) { } +} + +declare function foo(arg: (x: D) => number): string; +declare function foo(arg: (x: C) => any): string; +declare function foo(arg: (x: B) => any): number; + +var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + +var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. + +var result3: string = foo(x => { // x has type D + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error + return y; +}); + + +//// [overloadresolutionWithConstraintCheckingDeferred.js] +"use strict"; +class G { + constructor(x) { } +} +var result = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +var result2 = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +var result3 = foo(x => { + var y = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error + return y; +}); diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c06f37a086801 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).symbols @@ -0,0 +1,80 @@ +//// [tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts] //// + +=== overloadresolutionWithConstraintCheckingDeferred.ts === +interface A { x } +>A : Symbol(A, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 0)) +>x : Symbol(A.x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 13)) + +interface B { x; y } +>B : Symbol(B, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 17)) +>x : Symbol(B.x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 13)) +>y : Symbol(B.y, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 16)) + +interface C { z } +>C : Symbol(C, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 20)) +>z : Symbol(C.z, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 2, 13)) + +interface D { q } +>D : Symbol(D, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 2, 17)) +>q : Symbol(D.q, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 13)) + +class G { +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>T : Symbol(T, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 5, 8)) +>A : Symbol(A, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 0)) + + constructor(x: T) { } +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 6, 16)) +>T : Symbol(T, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 5, 8)) +} + +declare function foo(arg: (x: D) => number): string; +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>arg : Symbol(arg, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 21)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 27)) +>D : Symbol(D, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 2, 17)) + +declare function foo(arg: (x: C) => any): string; +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>arg : Symbol(arg, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 21)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 27)) +>C : Symbol(C, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 1, 20)) + +declare function foo(arg: (x: B) => any): number; +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>arg : Symbol(arg, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 11, 21)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 11, 27)) +>B : Symbol(B, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 0, 17)) + +var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result : Symbol(result, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 13, 3)) +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 13, 25)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 13, 25)) + +var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result2 : Symbol(result2, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 3)) +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 26)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 26)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 15, 26)) + +var result3: string = foo(x => { // x has type D +>result3 : Symbol(result3, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 3)) +>foo : Symbol(foo, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 7, 1), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 9, 52), Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 10, 49)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 26)) + + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error +>y : Symbol(y, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 18, 7)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 26)) +>G : Symbol(G, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 3, 17)) +>x : Symbol(x, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 17, 26)) + + return y; +>y : Symbol(y, Decl(overloadresolutionWithConstraintCheckingDeferred.ts, 18, 7)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types new file mode 100644 index 0000000000000..df9ec39e7e837 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types @@ -0,0 +1,78 @@ +//// [tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts] //// + +=== overloadresolutionWithConstraintCheckingDeferred.ts === +interface A { x } +>x : any + +interface B { x; y } +>x : any +>y : any + +interface C { z } +>z : any + +interface D { q } +>q : any + +class G { +>G : G + + constructor(x: T) { } +>x : T +} + +declare function foo(arg: (x: D) => number): string; +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>arg : (x: D) => number +>x : D + +declare function foo(arg: (x: C) => any): string; +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>arg : (x: C) => any +>x : C + +declare function foo(arg: (x: B) => any): number; +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>arg : (x: B) => any +>x : B + +var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result : number +>foo(x => new G(x)) : never +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>x => new G(x) : (x: D) => G +>x : D +>new G(x) : G +>G : typeof G +>x : D + +var result2: number = foo(x => new G(x)); // x has type D, new G(x) fails, so first overload is picked. +>result2 : number +>foo(x => new G(x)) : never +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>x => new G(x) : (x: D) => G +>x : D +>new G(x) : G +>G : typeof G +>x : D +>x : D + +var result3: string = foo(x => { // x has type D +>result3 : string +>foo(x => { // x has type D var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error return y;}) : never +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>x => { // x has type D var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error return y;} : (x: D) => G +>x : D + + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error +>y : G +>x : D +>new G(x) : G +>G : typeof G +>x : D + + return y; +>y : G + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt new file mode 100644 index 0000000000000..28167de70ad61 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt @@ -0,0 +1,37 @@ +parameterBindingDefaultReferencesSiblingThroughCall.ts(11,19): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(15,20): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(19,25): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Type 'any[]' is not assignable to type 'string'. + + +==== parameterBindingDefaultReferencesSiblingThroughCall.ts (4 errors) ==== + // A default in a destructured parameter that references a sibling element + // makes the sibling's type depend on itself: the type of 'a' comes from the + // parameter initializer '{}', which is padded with the types of the defaults, + // including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not + // for 'b = id(a)', where the padding reuses the signature resolved while 'a' + // was treated as non-inferrable any during contextual typing of '{}', which + // gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + + declare function id(v: T): T; + + function direct({ a = 1 as number | undefined, b = a } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + } + + function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + } + + function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + ~ +!!! error TS2322: Type 'any[]' is not assignable to type 'string'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).symbols new file mode 100644 index 0000000000000..06dbf91e4f588 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).symbols @@ -0,0 +1,53 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>v : Symbol(v, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 23)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : Symbol(direct, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 32)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 11, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : Symbol(viaCall, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 12, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 15, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : Symbol(viaCallArray, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 16, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 19, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types new file mode 100644 index 0000000000000..7c1aeb46582c6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : (v: T) => T +>v : T + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any +>id(a) : any +>id : (v: T) => T +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : ({ a, b }?: { a?: number | undefined; b?: any[] | undefined; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any[] +>id([a]) : any[] +>id : (v: T) => T +>[a] : any[] +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..28167de70ad61 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt @@ -0,0 +1,37 @@ +parameterBindingDefaultReferencesSiblingThroughCall.ts(11,19): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(15,20): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(19,25): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Type 'any[]' is not assignable to type 'string'. + + +==== parameterBindingDefaultReferencesSiblingThroughCall.ts (4 errors) ==== + // A default in a destructured parameter that references a sibling element + // makes the sibling's type depend on itself: the type of 'a' comes from the + // parameter initializer '{}', which is padded with the types of the defaults, + // including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not + // for 'b = id(a)', where the padding reuses the signature resolved while 'a' + // was treated as non-inferrable any during contextual typing of '{}', which + // gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + + declare function id(v: T): T; + + function direct({ a = 1 as number | undefined, b = a } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + } + + function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + } + + function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + ~ +!!! error TS2322: Type 'any[]' is not assignable to type 'string'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..06dbf91e4f588 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).symbols @@ -0,0 +1,53 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>v : Symbol(v, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 23)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : Symbol(direct, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 32)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 11, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : Symbol(viaCall, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 12, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 15, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : Symbol(viaCallArray, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 16, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 19, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types new file mode 100644 index 0000000000000..7c1aeb46582c6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : (v: T) => T +>v : T + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any +>id(a) : any +>id : (v: T) => T +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : ({ a, b }?: { a?: number | undefined; b?: any[] | undefined; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any[] +>id([a]) : any[] +>id : (v: T) => T +>[a] : any[] +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..c8d33c7ef3504 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,13 @@ +qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no exported member 'T'. + + +==== qualifiedNameCycleErrorCheckOrder.ts (1 errors) ==== + // Resolving n.T looks for a value n to suggest typeof, which needs the type of + // n, which is n.T. The missing member must be reported whichever is + // resolved first. + + declare const n: n.T; + ~ +!!! error TS2694: Namespace 'n' has no exported member 'T'. + declare namespace n {} + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..9ca975f52c7c4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +//// [qualifiedNameCycleErrorCheckOrder.ts] +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +declare namespace n {} + + +//// [qualifiedNameCycleErrorCheckOrder.js] +"use strict"; +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3540b50c66446 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>T : Symbol(n.T) + +declare namespace n {} +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..3fab9ef68e510 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : n.T +>n : any + +declare namespace n {} + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..c8d33c7ef3504 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,13 @@ +qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no exported member 'T'. + + +==== qualifiedNameCycleErrorCheckOrder.ts (1 errors) ==== + // Resolving n.T looks for a value n to suggest typeof, which needs the type of + // n, which is n.T. The missing member must be reported whichever is + // resolved first. + + declare const n: n.T; + ~ +!!! error TS2694: Namespace 'n' has no exported member 'T'. + declare namespace n {} + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..9ca975f52c7c4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +//// [qualifiedNameCycleErrorCheckOrder.ts] +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +declare namespace n {} + + +//// [qualifiedNameCycleErrorCheckOrder.js] +"use strict"; +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3540b50c66446 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>T : Symbol(n.T) + +declare namespace n {} +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..3fab9ef68e510 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : n.T +>n : any + +declare namespace n {} + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt b/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt index b119a342d2de9..9a55044866b75 100644 --- a/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt @@ -2,9 +2,9 @@ recursiveConditionalCrash4.ts(7,16): error TS2503: Cannot find namespace 'StrIte recursiveConditionalCrash4.ts(8,5): error TS2503: Cannot find namespace 'StrIter'. recursiveConditionalCrash4.ts(9,25): error TS2304: Cannot find name 'Add'. recursiveConditionalCrash4.ts(9,37): error TS2503: Cannot find namespace 'StrIter'. -recursiveConditionalCrash4.ts(10,7): error TS5114: Instantiations of type 'LengthDown' appear infinitely circular. +recursiveConditionalCrash4.ts(10,7): error TS2589: Type instantiation is excessively deep and possibly infinite. recursiveConditionalCrash4.ts(10,31): error TS2503: Cannot find namespace 'StrIter'. -recursiveConditionalCrash4.ts(16,7): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +recursiveConditionalCrash4.ts(16,7): error TS2589: Type instantiation is excessively deep and possibly infinite. ==== recursiveConditionalCrash4.ts (7 errors) ==== @@ -27,7 +27,7 @@ recursiveConditionalCrash4.ts(16,7): error TS5114: Instantiations of type 'Foo' !!! error TS2503: Cannot find namespace 'StrIter'. : LengthDown> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'LengthDown' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~~~~~~~ !!! error TS2503: Cannot find namespace 'StrIter'. : Length; @@ -37,6 +37,6 @@ recursiveConditionalCrash4.ts(16,7): error TS5114: Instantiations of type 'Foo' ? Foo : Foo ~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. : unknown; \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/recursiveConditionalTypes.types b/tsc/testdata/baselines/reference/compiler/recursiveConditionalTypes.types index 73d9df41e47d2..49e5284d2f967 100644 --- a/tsc/testdata/baselines/reference/compiler/recursiveConditionalTypes.types +++ b/tsc/testdata/baselines/reference/compiler/recursiveConditionalTypes.types @@ -223,7 +223,7 @@ unbox(b4); // { value: { value: typeof b4 }} >b4 : { value: { value: { value: typeof b4; }; }; } unbox({ value: { value: { get value() { return this; } }}}); // { readonly value: ... } ->unbox({ value: { value: { get value() { return this; } }}}) : { readonly value: { readonly value: any; }; } +>unbox({ value: { value: { get value() { return this; } }}}) : { readonly value: any; } >unbox : (box: RecBox) => T >{ value: { value: { get value() { return this; } }}} : { value: { value: { readonly value: { readonly value: any; }; }; }; } >value : { value: { readonly value: { readonly value: any; }; }; } @@ -231,7 +231,7 @@ unbox({ value: { value: { get value() { return this; } }}}); // { readonly valu >value : { readonly value: { readonly value: any; }; } >{ get value() { return this; } } : { readonly value: { readonly value: any; }; } >value : { readonly value: any; } ->this : { readonly value: any; } | RecBox<{ readonly value: { readonly value: any; }; }> +>this : RecBox<{ readonly value: any; }> // Inference from nested instantiations of same generic types diff --git a/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.symbols b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.symbols new file mode 100644 index 0000000000000..90c083e029559 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.symbols @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts] //// + +=== recursiveGenericInterfaceDeclarationOrder.ts === +// The assignment is valid, as method parameters are compared bivariantly, and +// must be accepted whichever of the interfaces is declared first. + +type M = { kind: "m" }; +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>kind : Symbol(kind, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 3, 10)) + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Symbol(Filtered, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 3, 23)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) + +interface Config { measure: keyof T } +>Config : Symbol(Config, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 74)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 17)) +>measure : Symbol(Config.measure, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 21)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 17)) + +interface Ref { dataset: DS, N> } +>Ref : Symbol(Ref, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 40)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 14)) +>dataset : Symbol(Ref.dataset, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 18)) +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 14)) + +interface DS { +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 13)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 15)) + + a(config: Config>): void; +>a : Symbol(DS.a, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 20)) +>config : Symbol(config, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 8, 4)) +>Config : Symbol(Config, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 74)) +>Filtered : Symbol(Filtered, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 3, 23)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 13)) + + b: Ref; +>b : Symbol(DS.b, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 8, 39)) +>Ref : Symbol(Ref, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 40)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 15)) +} +declare const x: DS<{ total: M }, string>; +>x : Symbol(x, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 11, 13)) +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>total : Symbol(total, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 11, 21)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) + +export const y: DS, string> = x; +>y : Symbol(y, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 12, 12)) +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>x : Symbol(x, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 11, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.types b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.types new file mode 100644 index 0000000000000..5bdcbb5101541 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.types @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts] //// + +=== recursiveGenericInterfaceDeclarationOrder.ts === +// The assignment is valid, as method parameters are compared bivariantly, and +// must be accepted whichever of the interfaces is declared first. + +type M = { kind: "m" }; +>M : M +>kind : "m" + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Filtered + +interface Config { measure: keyof T } +>measure : keyof T + +interface Ref { dataset: DS, N> } +>dataset : DS, N> + +interface DS { + a(config: Config>): void; +>a : (config: Config>) => void +>config : Config> + + b: Ref; +>b : Ref +} +declare const x: DS<{ total: M }, string>; +>x : DS<{ total: M; }, string> +>total : M + +export const y: DS, string> = x; +>y : DS, string> +>x : DS<{ total: M; }, string> + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.errors.txt b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.errors.txt new file mode 100644 index 0000000000000..1b54f45a5c6a5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.errors.txt @@ -0,0 +1,227 @@ +annotations.ts(18,1): error TS2322: Type 'AnnotatedTree' is not assignable to type 'AnnotatedTree'. + Type 'unknown' is not assignable to type 'string'. +annotations.ts(19,1): error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. + Types of property 'listener' are incompatible. + Type '(batch: AnnotatedStore) => void' is not assignable to type '(batch: AnnotatedStore) => void'. + Types of parameters 'batch' and 'batch' are incompatible. + Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. + Types of property 'value' are incompatible. + Type 'unknown[]' is not assignable to type 'string[]'. + Type 'unknown' is not assignable to type 'string'. +annotations.ts(20,1): error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. + Types of property 'value' are incompatible. + Type 'unknown' is not assignable to type 'string'. +columnDefFirst.ts(14,1): error TS2322: Type 'ColumnDef<{ name: string; }, string>' is not assignable to type 'ColumnDef<{ name: string; }, unknown>'. + Type 'unknown' is not assignable to type 'string'. +listenerFirst.ts(14,1): error TS2322: Type 'Listener' is not assignable to type 'Listener'. + Type 'unknown' is not assignable to type 'string'. +nestedComposition.ts(14,1): error TS2322: Type 'Outer' is not assignable to type 'Outer'. + Types of property 'next' are incompatible. + Type 'Inner>' is not assignable to type 'Inner>'. + Type 'Outer' is not assignable to type 'Outer'. + Types of property 'value' are incompatible. + Type 'unknown' is not assignable to type 'string'. +nestedComposition.ts(15,1): error TS2322: Type 'Outer' is not assignable to type 'Outer'. + Types of property 'value' are incompatible. + Type 'unknown' is not assignable to type 'string'. +positiveRecursion.ts(18,1): error TS2322: Type 'Tree' is not assignable to type 'Tree'. + Type 'unknown' is not assignable to type 'string'. +structuralMeasurement.ts(23,1): error TS2322: Type 'GenericMethod' is not assignable to type 'GenericMethod'. + Type 'unknown' is not assignable to type 'string'. + + +==== storeFirst.ts (0 errors) ==== + export {}; + + interface Store { + value: T; + listener: Listener; + } + type Listener = (batch: Store) => void; + + declare let strings: Store; + declare let unknowns: Store; + declare let stringListener: Listener; + declare let unknownListener: Listener; + + unknowns = strings; // Error + unknownListener = stringListener; // Error + +==== listenerFirst.ts (1 errors) ==== + export {}; + + type Listener = (batch: Store) => void; + interface Store { + listener: Listener; + value: T; + } + + declare let strings: Store; + declare let unknowns: Store; + declare let stringListener: Listener; + declare let unknownListener: Listener; + + unknownListener = stringListener; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'Listener' is not assignable to type 'Listener'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + unknowns = strings; // Error + +==== columnDefFirst.ts (1 errors) ==== + export {}; + + interface ColumnDef { + cell?: (column: Column) => void; + } + interface Column { + accessorFn?: (row: Row) => Value; + columnDef: ColumnDef; + } + + declare let stringColumn: ColumnDef<{ name: string }, string>; + declare let unknownColumn: ColumnDef<{ name: string }, unknown>; + + unknownColumn = stringColumn; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ColumnDef<{ name: string; }, string>' is not assignable to type 'ColumnDef<{ name: string; }, unknown>'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + stringColumn = unknownColumn; // Error + +==== columnFirst.ts (0 errors) ==== + export {}; + + interface Column { + columnDef: ColumnDef; + accessorFn?: (row: Row) => Value; + } + interface ColumnDef { + cell?: (column: Column) => void; + } + + declare let stringColumn: ColumnDef<{ name: string }, string>; + declare let unknownColumn: ColumnDef<{ name: string }, unknown>; + + unknownColumn = stringColumn; // Error + stringColumn = unknownColumn; // Error + +==== positiveRecursion.ts (1 errors) ==== + export {}; + + interface Tree { + readonly value: T; + readonly children: readonly Tree[]; + readonly metadata: Map; + } + interface Phantom { + next: Phantom; + } + + declare let stringTree: Tree; + declare let unknownTree: Tree; + declare let stringPhantom: Phantom; + declare let numberPhantom: Phantom; + + unknownTree = stringTree; + stringTree = unknownTree; // Error + ~~~~~~~~~~ +!!! error TS2322: Type 'Tree' is not assignable to type 'Tree'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + stringPhantom = numberPhantom; + numberPhantom = stringPhantom; + +==== nestedComposition.ts (2 errors) ==== + export {}; + + interface Outer { + value: T; + next: Inner>; + } + interface Inner { + consume: (value: T) => void; + } + + declare let strings: Outer; + declare let unknowns: Outer; + + unknowns = strings; // Error + ~~~~~~~~ +!!! error TS2322: Type 'Outer' is not assignable to type 'Outer'. +!!! error TS2322: Types of property 'next' are incompatible. +!!! error TS2322: Type 'Inner>' is not assignable to type 'Inner>'. +!!! error TS2322: Type 'Outer' is not assignable to type 'Outer'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + strings = unknowns; // Error + ~~~~~~~ +!!! error TS2322: Type 'Outer' is not assignable to type 'Outer'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + +==== annotations.ts (3 errors) ==== + export {}; + + interface AnnotatedTree { + readonly value: T; + readonly children: AnnotatedTree[]; + } + interface AnnotatedStore { + value: T; + listener: (batch: AnnotatedStore) => void; + } + + declare let stringTree: AnnotatedTree; + declare let unknownTree: AnnotatedTree; + declare let stringStore: AnnotatedStore; + declare let unknownStore: AnnotatedStore; + + unknownTree = stringTree; + stringTree = unknownTree; // Error + ~~~~~~~~~~ +!!! error TS2322: Type 'AnnotatedTree' is not assignable to type 'AnnotatedTree'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + unknownStore = stringStore; // Error + ~~~~~~~~~~~~ +!!! error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. +!!! error TS2322: Types of property 'listener' are incompatible. +!!! error TS2322: Type '(batch: AnnotatedStore) => void' is not assignable to type '(batch: AnnotatedStore) => void'. +!!! error TS2322: Types of parameters 'batch' and 'batch' are incompatible. +!!! error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown[]' is not assignable to type 'string[]'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + stringStore = unknownStore; // Error + ~~~~~~~~~~~ +!!! error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + +==== structuralMeasurement.ts (1 errors) ==== + export {}; + + interface GenericMethod { + value: T; + next: (value: U) => GenericMethod; + } + interface Projected { + value: T["value"]; + next: Projected; + } + interface Method { + value: T; + accept(value: Method): void; + } + + declare let strings: GenericMethod; + declare let unknowns: GenericMethod; + declare let stringMethod: Method; + declare let unknownMethod: Method; + declare let projected: Projected<{ value: string; extra: number }>; + + unknowns = strings; + strings = unknowns; // Error + ~~~~~~~ +!!! error TS2322: Type 'GenericMethod' is not assignable to type 'GenericMethod'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + unknownMethod = stringMethod; + const widened: Projected<{ value: string }> = projected; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.symbols b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.symbols new file mode 100644 index 0000000000000..5609297b7b09a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.symbols @@ -0,0 +1,455 @@ +//// [tests/cases/compiler/recursiveVarianceFixedPoint.ts] //// + +=== storeFirst.ts === +export {}; + +interface Store { +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) +>T : Symbol(T, Decl(storeFirst.ts, 2, 16)) + + value: T; +>value : Symbol(Store.value, Decl(storeFirst.ts, 2, 20)) +>T : Symbol(T, Decl(storeFirst.ts, 2, 16)) + + listener: Listener; +>listener : Symbol(Store.listener, Decl(storeFirst.ts, 3, 13)) +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) +>T : Symbol(T, Decl(storeFirst.ts, 2, 16)) +} +type Listener = (batch: Store) => void; +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) +>T : Symbol(T, Decl(storeFirst.ts, 6, 14)) +>batch : Symbol(batch, Decl(storeFirst.ts, 6, 20)) +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) +>T : Symbol(T, Decl(storeFirst.ts, 6, 14)) + +declare let strings: Store; +>strings : Symbol(strings, Decl(storeFirst.ts, 8, 11)) +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) + +declare let unknowns: Store; +>unknowns : Symbol(unknowns, Decl(storeFirst.ts, 9, 11)) +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) + +declare let stringListener: Listener; +>stringListener : Symbol(stringListener, Decl(storeFirst.ts, 10, 11)) +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) + +declare let unknownListener: Listener; +>unknownListener : Symbol(unknownListener, Decl(storeFirst.ts, 11, 11)) +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) + +unknowns = strings; // Error +>unknowns : Symbol(unknowns, Decl(storeFirst.ts, 9, 11)) +>strings : Symbol(strings, Decl(storeFirst.ts, 8, 11)) + +unknownListener = stringListener; // Error +>unknownListener : Symbol(unknownListener, Decl(storeFirst.ts, 11, 11)) +>stringListener : Symbol(stringListener, Decl(storeFirst.ts, 10, 11)) + +=== listenerFirst.ts === +export {}; + +type Listener = (batch: Store) => void; +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) +>T : Symbol(T, Decl(listenerFirst.ts, 2, 14)) +>batch : Symbol(batch, Decl(listenerFirst.ts, 2, 20)) +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) +>T : Symbol(T, Decl(listenerFirst.ts, 2, 14)) + +interface Store { +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) +>T : Symbol(T, Decl(listenerFirst.ts, 3, 16)) + + listener: Listener; +>listener : Symbol(Store.listener, Decl(listenerFirst.ts, 3, 20)) +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) +>T : Symbol(T, Decl(listenerFirst.ts, 3, 16)) + + value: T; +>value : Symbol(Store.value, Decl(listenerFirst.ts, 4, 26)) +>T : Symbol(T, Decl(listenerFirst.ts, 3, 16)) +} + +declare let strings: Store; +>strings : Symbol(strings, Decl(listenerFirst.ts, 8, 11)) +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) + +declare let unknowns: Store; +>unknowns : Symbol(unknowns, Decl(listenerFirst.ts, 9, 11)) +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) + +declare let stringListener: Listener; +>stringListener : Symbol(stringListener, Decl(listenerFirst.ts, 10, 11)) +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) + +declare let unknownListener: Listener; +>unknownListener : Symbol(unknownListener, Decl(listenerFirst.ts, 11, 11)) +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) + +unknownListener = stringListener; // Error +>unknownListener : Symbol(unknownListener, Decl(listenerFirst.ts, 11, 11)) +>stringListener : Symbol(stringListener, Decl(listenerFirst.ts, 10, 11)) + +unknowns = strings; // Error +>unknowns : Symbol(unknowns, Decl(listenerFirst.ts, 9, 11)) +>strings : Symbol(strings, Decl(listenerFirst.ts, 8, 11)) + +=== columnDefFirst.ts === +export {}; + +interface ColumnDef { +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 2, 20)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 2, 24)) + + cell?: (column: Column) => void; +>cell : Symbol(ColumnDef.cell, Decl(columnDefFirst.ts, 2, 43)) +>column : Symbol(column, Decl(columnDefFirst.ts, 3, 12)) +>Column : Symbol(Column, Decl(columnDefFirst.ts, 4, 1)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 2, 20)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 2, 24)) +} +interface Column { +>Column : Symbol(Column, Decl(columnDefFirst.ts, 4, 1)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 5, 17)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 5, 21)) + + accessorFn?: (row: Row) => Value; +>accessorFn : Symbol(Column.accessorFn, Decl(columnDefFirst.ts, 5, 40)) +>row : Symbol(row, Decl(columnDefFirst.ts, 6, 18)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 5, 17)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 5, 21)) + + columnDef: ColumnDef; +>columnDef : Symbol(Column.columnDef, Decl(columnDefFirst.ts, 6, 37)) +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 5, 17)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 5, 21)) +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : Symbol(stringColumn, Decl(columnDefFirst.ts, 10, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>name : Symbol(name, Decl(columnDefFirst.ts, 10, 37)) + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : Symbol(unknownColumn, Decl(columnDefFirst.ts, 11, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>name : Symbol(name, Decl(columnDefFirst.ts, 11, 38)) + +unknownColumn = stringColumn; // Error +>unknownColumn : Symbol(unknownColumn, Decl(columnDefFirst.ts, 11, 11)) +>stringColumn : Symbol(stringColumn, Decl(columnDefFirst.ts, 10, 11)) + +stringColumn = unknownColumn; // Error +>stringColumn : Symbol(stringColumn, Decl(columnDefFirst.ts, 10, 11)) +>unknownColumn : Symbol(unknownColumn, Decl(columnDefFirst.ts, 11, 11)) + +=== columnFirst.ts === +export {}; + +interface Column { +>Column : Symbol(Column, Decl(columnFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnFirst.ts, 2, 17)) +>Value : Symbol(Value, Decl(columnFirst.ts, 2, 21)) + + columnDef: ColumnDef; +>columnDef : Symbol(Column.columnDef, Decl(columnFirst.ts, 2, 40)) +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>Row : Symbol(Row, Decl(columnFirst.ts, 2, 17)) +>Value : Symbol(Value, Decl(columnFirst.ts, 2, 21)) + + accessorFn?: (row: Row) => Value; +>accessorFn : Symbol(Column.accessorFn, Decl(columnFirst.ts, 3, 37)) +>row : Symbol(row, Decl(columnFirst.ts, 4, 18)) +>Row : Symbol(Row, Decl(columnFirst.ts, 2, 17)) +>Value : Symbol(Value, Decl(columnFirst.ts, 2, 21)) +} +interface ColumnDef { +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>Row : Symbol(Row, Decl(columnFirst.ts, 6, 20)) +>Value : Symbol(Value, Decl(columnFirst.ts, 6, 24)) + + cell?: (column: Column) => void; +>cell : Symbol(ColumnDef.cell, Decl(columnFirst.ts, 6, 43)) +>column : Symbol(column, Decl(columnFirst.ts, 7, 12)) +>Column : Symbol(Column, Decl(columnFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnFirst.ts, 6, 20)) +>Value : Symbol(Value, Decl(columnFirst.ts, 6, 24)) +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : Symbol(stringColumn, Decl(columnFirst.ts, 10, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>name : Symbol(name, Decl(columnFirst.ts, 10, 37)) + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : Symbol(unknownColumn, Decl(columnFirst.ts, 11, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>name : Symbol(name, Decl(columnFirst.ts, 11, 38)) + +unknownColumn = stringColumn; // Error +>unknownColumn : Symbol(unknownColumn, Decl(columnFirst.ts, 11, 11)) +>stringColumn : Symbol(stringColumn, Decl(columnFirst.ts, 10, 11)) + +stringColumn = unknownColumn; // Error +>stringColumn : Symbol(stringColumn, Decl(columnFirst.ts, 10, 11)) +>unknownColumn : Symbol(unknownColumn, Decl(columnFirst.ts, 11, 11)) + +=== positiveRecursion.ts === +export {}; + +interface Tree { +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) +>T : Symbol(T, Decl(positiveRecursion.ts, 2, 15)) + + readonly value: T; +>value : Symbol(Tree.value, Decl(positiveRecursion.ts, 2, 19)) +>T : Symbol(T, Decl(positiveRecursion.ts, 2, 15)) + + readonly children: readonly Tree[]; +>children : Symbol(Tree.children, Decl(positiveRecursion.ts, 3, 22)) +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) +>T : Symbol(T, Decl(positiveRecursion.ts, 2, 15)) + + readonly metadata: Map; +>metadata : Symbol(Tree.metadata, Decl(positiveRecursion.ts, 4, 42)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +} +interface Phantom { +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) +>T : Symbol(T, Decl(positiveRecursion.ts, 7, 18)) + + next: Phantom; +>next : Symbol(Phantom.next, Decl(positiveRecursion.ts, 7, 22)) +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) +>T : Symbol(T, Decl(positiveRecursion.ts, 7, 18)) +} + +declare let stringTree: Tree; +>stringTree : Symbol(stringTree, Decl(positiveRecursion.ts, 11, 11)) +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) + +declare let unknownTree: Tree; +>unknownTree : Symbol(unknownTree, Decl(positiveRecursion.ts, 12, 11)) +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) + +declare let stringPhantom: Phantom; +>stringPhantom : Symbol(stringPhantom, Decl(positiveRecursion.ts, 13, 11)) +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) + +declare let numberPhantom: Phantom; +>numberPhantom : Symbol(numberPhantom, Decl(positiveRecursion.ts, 14, 11)) +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) + +unknownTree = stringTree; +>unknownTree : Symbol(unknownTree, Decl(positiveRecursion.ts, 12, 11)) +>stringTree : Symbol(stringTree, Decl(positiveRecursion.ts, 11, 11)) + +stringTree = unknownTree; // Error +>stringTree : Symbol(stringTree, Decl(positiveRecursion.ts, 11, 11)) +>unknownTree : Symbol(unknownTree, Decl(positiveRecursion.ts, 12, 11)) + +stringPhantom = numberPhantom; +>stringPhantom : Symbol(stringPhantom, Decl(positiveRecursion.ts, 13, 11)) +>numberPhantom : Symbol(numberPhantom, Decl(positiveRecursion.ts, 14, 11)) + +numberPhantom = stringPhantom; +>numberPhantom : Symbol(numberPhantom, Decl(positiveRecursion.ts, 14, 11)) +>stringPhantom : Symbol(stringPhantom, Decl(positiveRecursion.ts, 13, 11)) + +=== nestedComposition.ts === +export {}; + +interface Outer { +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) +>T : Symbol(T, Decl(nestedComposition.ts, 2, 16)) + + value: T; +>value : Symbol(Outer.value, Decl(nestedComposition.ts, 2, 20)) +>T : Symbol(T, Decl(nestedComposition.ts, 2, 16)) + + next: Inner>; +>next : Symbol(Outer.next, Decl(nestedComposition.ts, 3, 13)) +>Inner : Symbol(Inner, Decl(nestedComposition.ts, 5, 1)) +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) +>T : Symbol(T, Decl(nestedComposition.ts, 2, 16)) +} +interface Inner { +>Inner : Symbol(Inner, Decl(nestedComposition.ts, 5, 1)) +>T : Symbol(T, Decl(nestedComposition.ts, 6, 16)) + + consume: (value: T) => void; +>consume : Symbol(Inner.consume, Decl(nestedComposition.ts, 6, 20)) +>value : Symbol(value, Decl(nestedComposition.ts, 7, 14)) +>T : Symbol(T, Decl(nestedComposition.ts, 6, 16)) +} + +declare let strings: Outer; +>strings : Symbol(strings, Decl(nestedComposition.ts, 10, 11)) +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) + +declare let unknowns: Outer; +>unknowns : Symbol(unknowns, Decl(nestedComposition.ts, 11, 11)) +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) + +unknowns = strings; // Error +>unknowns : Symbol(unknowns, Decl(nestedComposition.ts, 11, 11)) +>strings : Symbol(strings, Decl(nestedComposition.ts, 10, 11)) + +strings = unknowns; // Error +>strings : Symbol(strings, Decl(nestedComposition.ts, 10, 11)) +>unknowns : Symbol(unknowns, Decl(nestedComposition.ts, 11, 11)) + +=== annotations.ts === +export {}; + +interface AnnotatedTree { +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) +>T : Symbol(T, Decl(annotations.ts, 2, 24)) + + readonly value: T; +>value : Symbol(AnnotatedTree.value, Decl(annotations.ts, 2, 32)) +>T : Symbol(T, Decl(annotations.ts, 2, 24)) + + readonly children: AnnotatedTree[]; +>children : Symbol(AnnotatedTree.children, Decl(annotations.ts, 3, 22)) +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) +>T : Symbol(T, Decl(annotations.ts, 2, 24)) +} +interface AnnotatedStore { +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) +>T : Symbol(T, Decl(annotations.ts, 6, 25)) + + value: T; +>value : Symbol(AnnotatedStore.value, Decl(annotations.ts, 6, 36)) +>T : Symbol(T, Decl(annotations.ts, 6, 25)) + + listener: (batch: AnnotatedStore) => void; +>listener : Symbol(AnnotatedStore.listener, Decl(annotations.ts, 7, 13)) +>batch : Symbol(batch, Decl(annotations.ts, 8, 15)) +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) +>T : Symbol(T, Decl(annotations.ts, 6, 25)) +} + +declare let stringTree: AnnotatedTree; +>stringTree : Symbol(stringTree, Decl(annotations.ts, 11, 11)) +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) + +declare let unknownTree: AnnotatedTree; +>unknownTree : Symbol(unknownTree, Decl(annotations.ts, 12, 11)) +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) + +declare let stringStore: AnnotatedStore; +>stringStore : Symbol(stringStore, Decl(annotations.ts, 13, 11)) +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) + +declare let unknownStore: AnnotatedStore; +>unknownStore : Symbol(unknownStore, Decl(annotations.ts, 14, 11)) +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) + +unknownTree = stringTree; +>unknownTree : Symbol(unknownTree, Decl(annotations.ts, 12, 11)) +>stringTree : Symbol(stringTree, Decl(annotations.ts, 11, 11)) + +stringTree = unknownTree; // Error +>stringTree : Symbol(stringTree, Decl(annotations.ts, 11, 11)) +>unknownTree : Symbol(unknownTree, Decl(annotations.ts, 12, 11)) + +unknownStore = stringStore; // Error +>unknownStore : Symbol(unknownStore, Decl(annotations.ts, 14, 11)) +>stringStore : Symbol(stringStore, Decl(annotations.ts, 13, 11)) + +stringStore = unknownStore; // Error +>stringStore : Symbol(stringStore, Decl(annotations.ts, 13, 11)) +>unknownStore : Symbol(unknownStore, Decl(annotations.ts, 14, 11)) + +=== structuralMeasurement.ts === +export {}; + +interface GenericMethod { +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 2, 24)) + + value: T; +>value : Symbol(GenericMethod.value, Decl(structuralMeasurement.ts, 2, 28)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 2, 24)) + + next: (value: U) => GenericMethod; +>next : Symbol(GenericMethod.next, Decl(structuralMeasurement.ts, 3, 13)) +>U : Symbol(U, Decl(structuralMeasurement.ts, 4, 11)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 4, 14)) +>U : Symbol(U, Decl(structuralMeasurement.ts, 4, 11)) +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 2, 24)) +} +interface Projected { +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 6, 20)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 6, 31)) + + value: T["value"]; +>value : Symbol(Projected.value, Decl(structuralMeasurement.ts, 6, 51)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 6, 20)) + + next: Projected; +>next : Symbol(Projected.next, Decl(structuralMeasurement.ts, 7, 22)) +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 6, 20)) +} +interface Method { +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 10, 17)) + + value: T; +>value : Symbol(Method.value, Decl(structuralMeasurement.ts, 10, 21)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 10, 17)) + + accept(value: Method): void; +>accept : Symbol(Method.accept, Decl(structuralMeasurement.ts, 11, 13)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 12, 11)) +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 10, 17)) +} + +declare let strings: GenericMethod; +>strings : Symbol(strings, Decl(structuralMeasurement.ts, 15, 11)) +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) + +declare let unknowns: GenericMethod; +>unknowns : Symbol(unknowns, Decl(structuralMeasurement.ts, 16, 11)) +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) + +declare let stringMethod: Method; +>stringMethod : Symbol(stringMethod, Decl(structuralMeasurement.ts, 17, 11)) +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) + +declare let unknownMethod: Method; +>unknownMethod : Symbol(unknownMethod, Decl(structuralMeasurement.ts, 18, 11)) +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) + +declare let projected: Projected<{ value: string; extra: number }>; +>projected : Symbol(projected, Decl(structuralMeasurement.ts, 19, 11)) +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 19, 34)) +>extra : Symbol(extra, Decl(structuralMeasurement.ts, 19, 49)) + +unknowns = strings; +>unknowns : Symbol(unknowns, Decl(structuralMeasurement.ts, 16, 11)) +>strings : Symbol(strings, Decl(structuralMeasurement.ts, 15, 11)) + +strings = unknowns; // Error +>strings : Symbol(strings, Decl(structuralMeasurement.ts, 15, 11)) +>unknowns : Symbol(unknowns, Decl(structuralMeasurement.ts, 16, 11)) + +unknownMethod = stringMethod; +>unknownMethod : Symbol(unknownMethod, Decl(structuralMeasurement.ts, 18, 11)) +>stringMethod : Symbol(stringMethod, Decl(structuralMeasurement.ts, 17, 11)) + +const widened: Projected<{ value: string }> = projected; +>widened : Symbol(widened, Decl(structuralMeasurement.ts, 24, 5)) +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 24, 26)) +>projected : Symbol(projected, Decl(structuralMeasurement.ts, 19, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.types b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.types new file mode 100644 index 0000000000000..e26d435575c06 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.types @@ -0,0 +1,344 @@ +//// [tests/cases/compiler/recursiveVarianceFixedPoint.ts] //// + +=== storeFirst.ts === +export {}; + +interface Store { + value: T; +>value : T + + listener: Listener; +>listener : Listener +} +type Listener = (batch: Store) => void; +>Listener : Listener +>batch : Store + +declare let strings: Store; +>strings : Store + +declare let unknowns: Store; +>unknowns : Store + +declare let stringListener: Listener; +>stringListener : Listener + +declare let unknownListener: Listener; +>unknownListener : Listener + +unknowns = strings; // Error +>unknowns = strings : Store +>unknowns : Store +>strings : Store + +unknownListener = stringListener; // Error +>unknownListener = stringListener : Listener +>unknownListener : Listener +>stringListener : Listener + +=== listenerFirst.ts === +export {}; + +type Listener = (batch: Store) => void; +>Listener : Listener +>batch : Store + +interface Store { + listener: Listener; +>listener : Listener + + value: T; +>value : T +} + +declare let strings: Store; +>strings : Store + +declare let unknowns: Store; +>unknowns : Store + +declare let stringListener: Listener; +>stringListener : Listener + +declare let unknownListener: Listener; +>unknownListener : Listener + +unknownListener = stringListener; // Error +>unknownListener = stringListener : Listener +>unknownListener : Listener +>stringListener : Listener + +unknowns = strings; // Error +>unknowns = strings : Store +>unknowns : Store +>strings : Store + +=== columnDefFirst.ts === +export {}; + +interface ColumnDef { + cell?: (column: Column) => void; +>cell : ((column: Column) => void) | undefined +>column : Column +} +interface Column { + accessorFn?: (row: Row) => Value; +>accessorFn : ((row: Row) => Value) | undefined +>row : Row + + columnDef: ColumnDef; +>columnDef : ColumnDef +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : ColumnDef<{ name: string; }, string> +>name : string + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>name : string + +unknownColumn = stringColumn; // Error +>unknownColumn = stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> + +stringColumn = unknownColumn; // Error +>stringColumn = unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> + +=== columnFirst.ts === +export {}; + +interface Column { + columnDef: ColumnDef; +>columnDef : ColumnDef + + accessorFn?: (row: Row) => Value; +>accessorFn : ((row: Row) => Value) | undefined +>row : Row +} +interface ColumnDef { + cell?: (column: Column) => void; +>cell : ((column: Column) => void) | undefined +>column : Column +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : ColumnDef<{ name: string; }, string> +>name : string + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>name : string + +unknownColumn = stringColumn; // Error +>unknownColumn = stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> + +stringColumn = unknownColumn; // Error +>stringColumn = unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> + +=== positiveRecursion.ts === +export {}; + +interface Tree { + readonly value: T; +>value : T + + readonly children: readonly Tree[]; +>children : readonly Tree[] + + readonly metadata: Map; +>metadata : Map +} +interface Phantom { + next: Phantom; +>next : Phantom +} + +declare let stringTree: Tree; +>stringTree : Tree + +declare let unknownTree: Tree; +>unknownTree : Tree + +declare let stringPhantom: Phantom; +>stringPhantom : Phantom + +declare let numberPhantom: Phantom; +>numberPhantom : Phantom + +unknownTree = stringTree; +>unknownTree = stringTree : Tree +>unknownTree : Tree +>stringTree : Tree + +stringTree = unknownTree; // Error +>stringTree = unknownTree : Tree +>stringTree : Tree +>unknownTree : Tree + +stringPhantom = numberPhantom; +>stringPhantom = numberPhantom : Phantom +>stringPhantom : Phantom +>numberPhantom : Phantom + +numberPhantom = stringPhantom; +>numberPhantom = stringPhantom : Phantom +>numberPhantom : Phantom +>stringPhantom : Phantom + +=== nestedComposition.ts === +export {}; + +interface Outer { + value: T; +>value : T + + next: Inner>; +>next : Inner> +} +interface Inner { + consume: (value: T) => void; +>consume : (value: T) => void +>value : T +} + +declare let strings: Outer; +>strings : Outer + +declare let unknowns: Outer; +>unknowns : Outer + +unknowns = strings; // Error +>unknowns = strings : Outer +>unknowns : Outer +>strings : Outer + +strings = unknowns; // Error +>strings = unknowns : Outer +>strings : Outer +>unknowns : Outer + +=== annotations.ts === +export {}; + +interface AnnotatedTree { + readonly value: T; +>value : T + + readonly children: AnnotatedTree[]; +>children : AnnotatedTree[] +} +interface AnnotatedStore { + value: T; +>value : T + + listener: (batch: AnnotatedStore) => void; +>listener : (batch: AnnotatedStore) => void +>batch : AnnotatedStore +} + +declare let stringTree: AnnotatedTree; +>stringTree : AnnotatedTree + +declare let unknownTree: AnnotatedTree; +>unknownTree : AnnotatedTree + +declare let stringStore: AnnotatedStore; +>stringStore : AnnotatedStore + +declare let unknownStore: AnnotatedStore; +>unknownStore : AnnotatedStore + +unknownTree = stringTree; +>unknownTree = stringTree : AnnotatedTree +>unknownTree : AnnotatedTree +>stringTree : AnnotatedTree + +stringTree = unknownTree; // Error +>stringTree = unknownTree : AnnotatedTree +>stringTree : AnnotatedTree +>unknownTree : AnnotatedTree + +unknownStore = stringStore; // Error +>unknownStore = stringStore : AnnotatedStore +>unknownStore : AnnotatedStore +>stringStore : AnnotatedStore + +stringStore = unknownStore; // Error +>stringStore = unknownStore : AnnotatedStore +>stringStore : AnnotatedStore +>unknownStore : AnnotatedStore + +=== structuralMeasurement.ts === +export {}; + +interface GenericMethod { + value: T; +>value : T + + next: (value: U) => GenericMethod; +>next : (value: U) => GenericMethod +>value : U +} +interface Projected { +>value : unknown + + value: T["value"]; +>value : T["value"] + + next: Projected; +>next : Projected +} +interface Method { + value: T; +>value : T + + accept(value: Method): void; +>accept : (value: Method) => void +>value : Method +} + +declare let strings: GenericMethod; +>strings : GenericMethod + +declare let unknowns: GenericMethod; +>unknowns : GenericMethod + +declare let stringMethod: Method; +>stringMethod : Method + +declare let unknownMethod: Method; +>unknownMethod : Method + +declare let projected: Projected<{ value: string; extra: number }>; +>projected : Projected<{ value: string; extra: number; }> +>value : string +>extra : number + +unknowns = strings; +>unknowns = strings : GenericMethod +>unknowns : GenericMethod +>strings : GenericMethod + +strings = unknowns; // Error +>strings = unknowns : GenericMethod +>strings : GenericMethod +>unknowns : GenericMethod + +unknownMethod = stringMethod; +>unknownMethod = stringMethod : Method +>unknownMethod : Method +>stringMethod : Method + +const widened: Projected<{ value: string }> = projected; +>widened : Projected<{ value: string; }> +>value : string +>projected : Projected<{ value: string; extra: number; }> + diff --git a/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.symbols b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.symbols new file mode 100644 index 0000000000000..517ce9e1866b7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts] //// + +=== reinstantiatedParameterKeepsResolvedType.ts === +// Instantiating E := {} turns the type of v into unknown. Inferring +// K := never must not then turn it into {}['V'][never], which is never. +interface I { +>I : Symbol(I, Decl(reinstantiatedParameterKeepsResolvedType.ts, 0, 0)) +>E : Symbol(E, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 12)) +>V : Symbol(V, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 23)) + + f(k: K, v: E['V'][K]): void; +>f : Symbol(I.f, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 39)) +>K : Symbol(K, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 6)) +>E : Symbol(E, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 12)) +>k : Symbol(k, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 30)) +>K : Symbol(K, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 6)) +>v : Symbol(v, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 35)) +>E : Symbol(E, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 12)) +>K : Symbol(K, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 6)) +} +declare const i: I<{}>; +>i : Symbol(i, Decl(reinstantiatedParameterKeepsResolvedType.ts, 5, 13)) +>I : Symbol(I, Decl(reinstantiatedParameterKeepsResolvedType.ts, 0, 0)) + +i.f("x" as never, 1); +>i.f : Symbol(I.f, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 39)) +>i : Symbol(i, Decl(reinstantiatedParameterKeepsResolvedType.ts, 5, 13)) +>f : Symbol(I.f, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 39)) + diff --git a/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.types b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.types new file mode 100644 index 0000000000000..824df47ea2a60 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.types @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts] //// + +=== reinstantiatedParameterKeepsResolvedType.ts === +// Instantiating E := {} turns the type of v into unknown. Inferring +// K := never must not then turn it into {}['V'][never], which is never. +interface I { +>V : object | undefined + + f(k: K, v: E['V'][K]): void; +>f : (k: K, v: E['V'][K]) => void +>k : K +>v : E["V"][K] +} +declare const i: I<{}>; +>i : I<{}> + +i.f("x" as never, 1); +>i.f("x" as never, 1) : void +>i.f : (k: K, v: unknown) => void +>i : I<{}> +>f : (k: K, v: unknown) => void +>"x" as never : never +>"x" : "x" +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt new file mode 100644 index 0000000000000..e208e03814c1f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt @@ -0,0 +1,55 @@ +relationComplexityError.ts(10,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. +relationComplexityError.ts(10,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. +relationComplexityError.ts(18,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(18,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(22,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(22,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(26,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. +relationComplexityError.ts(26,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + + +==== relationComplexityError.ts (8 errors) ==== + // Repro from #55630 + // Every comparison that needs a comparison that is too complex is too complex + // itself, whether or not that comparison happened before. + + type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; + type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; + type T2 = { a: string } | { b: number }; + + function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + } + + function f1(x: T1, y: T1 & T2) { + x = y; + } + + function f2(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + } + + function f3(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + } + + function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).symbols new file mode 100644 index 0000000000000..ea9543f81e755 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).symbols @@ -0,0 +1,91 @@ +//// [tests/cases/compiler/relationComplexityError.ts] //// + +=== relationComplexityError.ts === +// Repro from #55630 +// Every comparison that needs a comparison that is too complex is too complex +// itself, whether or not that comparison happened before. + +type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) + +type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) + +type T2 = { a: string } | { b: number }; +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) +>a : Symbol(a, Decl(relationComplexityError.ts, 6, 11)) +>b : Symbol(b, Decl(relationComplexityError.ts, 6, 27)) + +function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f0 : Symbol(f0, Decl(relationComplexityError.ts, 6, 40)) +>x : Symbol(x, Decl(relationComplexityError.ts, 8, 12)) +>p : Symbol(p, Decl(relationComplexityError.ts, 8, 16)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 8, 32)) +>p : Symbol(p, Decl(relationComplexityError.ts, 8, 37)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 8, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 8, 32)) +} + +function f1(x: T1, y: T1 & T2) { +>f1 : Symbol(f1, Decl(relationComplexityError.ts, 10, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 12, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 12, 18)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; +>x : Symbol(x, Decl(relationComplexityError.ts, 12, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 12, 18)) +} + +function f2(x: T1 | null, y: T1 & T2) { +>f2 : Symbol(f2, Decl(relationComplexityError.ts, 14, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 16, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 16, 25)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 16, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 16, 25)) +} + +function f3(x: T1 | null, y: T1 & T2) { +>f3 : Symbol(f3, Decl(relationComplexityError.ts, 18, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 20, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 20, 25)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 20, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 20, 25)) +} + +function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f4 : Symbol(f4, Decl(relationComplexityError.ts, 22, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 24, 12)) +>p : Symbol(p, Decl(relationComplexityError.ts, 24, 16)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 24, 32)) +>p : Symbol(p, Decl(relationComplexityError.ts, 24, 37)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 24, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 24, 32)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).types new file mode 100644 index 0000000000000..a6085a90e7675 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/relationComplexityError.ts] //// + +=== relationComplexityError.ts === +// Repro from #55630 +// Every comparison that needs a comparison that is too complex is too complex +// itself, whether or not that comparison happened before. + +type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; +>Digits : Digits + +type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; +>T1 : T1 + +type T2 = { a: string } | { b: number }; +>T2 : T2 +>a : string +>b : number + +function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f0 : (x: { p: T1 | null; }, y: { p: T1 & T2; }) => void +>x : { p: T1 | null; } +>p : T1 | null +>y : { p: T1 & T2; } +>p : T1 & T2 + + x = y; // Complexity error +>x = y : { p: T1 & T2; } +>x : { p: T1 | null; } +>y : { p: T1 & T2; } +} + +function f1(x: T1, y: T1 & T2) { +>f1 : (x: T1, y: T1 & T2) => void +>x : T1 +>y : T1 & T2 + + x = y; +>x = y : T1 & T2 +>x : T1 +>y : T1 & T2 +} + +function f2(x: T1 | null, y: T1 & T2) { +>f2 : (x: T1 | null, y: T1 & T2) => void +>x : T1 | null +>y : T1 & T2 + + x = y; // Complexity error +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 +} + +function f3(x: T1 | null, y: T1 & T2) { +>f3 : (x: T1 | null, y: T1 & T2) => void +>x : T1 | null +>y : T1 & T2 + + x = y; // Complexity error +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 +} + +function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f4 : (x: { p: T1 | null; }, y: { p: T1 & T2; }) => void +>x : { p: T1 | null; } +>p : T1 | null +>y : { p: T1 & T2; } +>p : T1 & T2 + + x = y; // Complexity error +>x = y : { p: T1 & T2; } +>x : { p: T1 | null; } +>y : { p: T1 & T2; } +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..e208e03814c1f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt @@ -0,0 +1,55 @@ +relationComplexityError.ts(10,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. +relationComplexityError.ts(10,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. +relationComplexityError.ts(18,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(18,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(22,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(22,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(26,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. +relationComplexityError.ts(26,5): error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + + +==== relationComplexityError.ts (8 errors) ==== + // Repro from #55630 + // Every comparison that needs a comparison that is too complex is too complex + // itself, whether or not that comparison happened before. + + type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; + type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; + type T2 = { a: string } | { b: number }; + + function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + } + + function f1(x: T1, y: T1 & T2) { + x = y; + } + + function f2(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + } + + function f3(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + } + + function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..ea9543f81e755 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).symbols @@ -0,0 +1,91 @@ +//// [tests/cases/compiler/relationComplexityError.ts] //// + +=== relationComplexityError.ts === +// Repro from #55630 +// Every comparison that needs a comparison that is too complex is too complex +// itself, whether or not that comparison happened before. + +type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) + +type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) + +type T2 = { a: string } | { b: number }; +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) +>a : Symbol(a, Decl(relationComplexityError.ts, 6, 11)) +>b : Symbol(b, Decl(relationComplexityError.ts, 6, 27)) + +function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f0 : Symbol(f0, Decl(relationComplexityError.ts, 6, 40)) +>x : Symbol(x, Decl(relationComplexityError.ts, 8, 12)) +>p : Symbol(p, Decl(relationComplexityError.ts, 8, 16)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 8, 32)) +>p : Symbol(p, Decl(relationComplexityError.ts, 8, 37)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 8, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 8, 32)) +} + +function f1(x: T1, y: T1 & T2) { +>f1 : Symbol(f1, Decl(relationComplexityError.ts, 10, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 12, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 12, 18)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; +>x : Symbol(x, Decl(relationComplexityError.ts, 12, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 12, 18)) +} + +function f2(x: T1 | null, y: T1 & T2) { +>f2 : Symbol(f2, Decl(relationComplexityError.ts, 14, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 16, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 16, 25)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 16, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 16, 25)) +} + +function f3(x: T1 | null, y: T1 & T2) { +>f3 : Symbol(f3, Decl(relationComplexityError.ts, 18, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 20, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 20, 25)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 20, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 20, 25)) +} + +function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f4 : Symbol(f4, Decl(relationComplexityError.ts, 22, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 24, 12)) +>p : Symbol(p, Decl(relationComplexityError.ts, 24, 16)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 24, 32)) +>p : Symbol(p, Decl(relationComplexityError.ts, 24, 37)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 24, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 24, 32)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).types new file mode 100644 index 0000000000000..a6085a90e7675 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/relationComplexityError.ts] //// + +=== relationComplexityError.ts === +// Repro from #55630 +// Every comparison that needs a comparison that is too complex is too complex +// itself, whether or not that comparison happened before. + +type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; +>Digits : Digits + +type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; +>T1 : T1 + +type T2 = { a: string } | { b: number }; +>T2 : T2 +>a : string +>b : number + +function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f0 : (x: { p: T1 | null; }, y: { p: T1 & T2; }) => void +>x : { p: T1 | null; } +>p : T1 | null +>y : { p: T1 & T2; } +>p : T1 & T2 + + x = y; // Complexity error +>x = y : { p: T1 & T2; } +>x : { p: T1 | null; } +>y : { p: T1 & T2; } +} + +function f1(x: T1, y: T1 & T2) { +>f1 : (x: T1, y: T1 & T2) => void +>x : T1 +>y : T1 & T2 + + x = y; +>x = y : T1 & T2 +>x : T1 +>y : T1 & T2 +} + +function f2(x: T1 | null, y: T1 & T2) { +>f2 : (x: T1 | null, y: T1 & T2) => void +>x : T1 | null +>y : T1 & T2 + + x = y; // Complexity error +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 +} + +function f3(x: T1 | null, y: T1 & T2) { +>f3 : (x: T1 | null, y: T1 & T2) => void +>x : T1 | null +>y : T1 & T2 + + x = y; // Complexity error +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 +} + +function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f4 : (x: { p: T1 | null; }, y: { p: T1 & T2; }) => void +>x : { p: T1 | null; } +>p : T1 | null +>y : { p: T1 & T2; } +>p : T1 & T2 + + x = y; // Complexity error +>x = y : { p: T1 & T2; } +>x : { p: T1 | null; } +>y : { p: T1 & T2; } +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..af652dc727d64 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,101 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T2 = { a: string } | { b: number }; +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) +>a : Symbol(a, Decl(relationComplexitySharedCheckOrder.ts, 6, 11)) +>b : Symbol(b, Decl(relationComplexitySharedCheckOrder.ts, 6, 27)) + +declare let x: T1 | null; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y1; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y2; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y3; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y4; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y5; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y6; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) + +declare const y: T1 & T2; +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..1a678796e4afb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : D + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : T1 + +type T2 = { a: string } | { b: number }; +>T2 : T2 +>a : string +>b : number + +declare let x: T1 | null; +>x : T1 | null + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +x = y1; +>x = y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 +>x : T1 | null +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +x = y2; +>x = y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 +>x : T1 | null +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +x = y3; +>x = y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 +>x : T1 | null +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +x = y4; +>x = y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 +>x : T1 | null +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +x = y5; +>x = y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 +>x : T1 | null +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +x = y6; +>x = y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 +>x : T1 | null +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +declare const y: T1 & T2; +>y : T1 & T2 + +x = y; +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..b09ae18f59a0c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,38 @@ +relationComplexitySharedCheckOrder.ts(20,1): error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. +relationComplexitySharedCheckOrder.ts(20,1): error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. +relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + + +==== relationComplexitySharedCheckOrder.ts (4 errors) ==== + // Relating y to x fresh caches too many comparisons. In program order the + // comparisons before it have cached all but a seventh of them. Whether + // relating y is too complex must not depend on which comes first. + + type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; + type T1 = `${D}${D}${D}${D}` | undefined; + type T2 = { a: string } | { b: number }; + declare let x: T1 | null; + declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; + x = y1; + declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; + x = y2; + declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; + x = y3; + declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; + x = y4; + declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; + x = y5; + declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; + x = y6; + ~ +!!! error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. + ~~~~~~ +!!! error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. + declare const y: T1 & T2; + x = y; + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..af652dc727d64 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,101 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T2 = { a: string } | { b: number }; +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) +>a : Symbol(a, Decl(relationComplexitySharedCheckOrder.ts, 6, 11)) +>b : Symbol(b, Decl(relationComplexitySharedCheckOrder.ts, 6, 27)) + +declare let x: T1 | null; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y1; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y2; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y3; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y4; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y5; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y6; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) + +declare const y: T1 & T2; +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..1a678796e4afb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : D + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : T1 + +type T2 = { a: string } | { b: number }; +>T2 : T2 +>a : string +>b : number + +declare let x: T1 | null; +>x : T1 | null + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +x = y1; +>x = y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 +>x : T1 | null +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +x = y2; +>x = y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 +>x : T1 | null +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +x = y3; +>x = y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 +>x : T1 | null +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +x = y4; +>x = y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 +>x : T1 | null +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +x = y5; +>x = y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 +>x : T1 | null +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +x = y6; +>x = y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 +>x : T1 | null +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +declare const y: T1 & T2; +>y : T1 & T2 + +x = y; +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..e733a24979f0e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,104 @@ +relationCycleNonMonotoneCheckOrder.ts(43,9): error TS2322: Type 'S2' is not assignable to type 'G2'. + Type '"d" | undefined' is not assignable to type '"d" | G1'. + Type 'undefined' is not assignable to type '"d" | G1'. + + +==== relationCycleNonMonotoneCheckOrder.ts (1 errors) ==== + // 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint + // 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to + // 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' + // whether or not 'A' was compared to 'C' first. + namespace inferenceConstraint { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = (x: T) => T["k"]; + type G = (x: A) => "c" | G | number; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // As above, with method signatures, which are compared bivariantly. + namespace inferenceConstraintMethod { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = { m(x: T): T["k"] }; + type G = { m(x: A): "c" | G | number }; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the + // reverse, so no answer is consistent for both. Each is answered as if + // compared first, assuming itself while relating the other, regardless + // of which assignment is checked first. + namespace inferenceConstraintMutual { + type A1 = { k?: "c"; f: S2 | G2 }; + type C1 = { [s: string]: "c" | G2; f: G2 }; + type S1 = (x: T) => T["k"]; + type G1 = (x: A1) => "c" | G2; + type A2 = { k?: "d"; f: S1 | G1 }; + type C2 = { [s: string]: "d" | G1; f: G1 }; + type S2 = (x: T) => T["k"]; + type G2 = (x: A2) => "d" | G1; + + declare let s1: S1; + declare let s2: S2; + let g1: G1 = s1; + let g2: G2 = s2; + ~~ +!!! error TS2322: Type 'S2' is not assignable to type 'G2'. +!!! error TS2322: Type '"d" | undefined' is not assignable to type '"d" | G1'. +!!! error TS2322: Type 'undefined' is not assignable to type '"d" | G1'. + declare let r1: S1 extends G1 ? true : false; + declare let r2: S2 extends G2 ? true : false; + } + + // 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member + // '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and + // relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on + // 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' + // first. + namespace discriminated { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + + declare let r1: Src extends Tgt ? true : false; + declare let r2: X extends Y ? true : false; + } + + // The excess property check of the object literal keeps the members of + // 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only + // if 'Src' relates to 'Tgt' as above. + namespace excessPropertyDiscriminant { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; + + declare let src: Src; + let o: Outer = { e: src, w: 1 }; + declare let r2: X extends Y ? true : false; + } + + // Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its + // optional parameter relates only if 'P' is not a strict subtype of 'Q', + // and relating 'P' to 'Q' compares 'F' to 'G' again before failing on + // 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. + namespace strictArity { + type P = { f: F | G; z: number }; + type Q = { f: G; z: 1 }; + type F = (x?: P) => 1; + type G = (x: Q | undefined) => number; + type WP = { a: P; b: string }; + type WQ = { a: Q }; + + declare let f: F, g: G, wp: WP, wq: WQ; + let a1 = [f, g]; + let a2 = [wp, wq]; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3bc451c9c78bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).symbols @@ -0,0 +1,361 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : Symbol(inferenceConstraint, Decl(relationCycleNonMonotoneCheckOrder.ts, 0, 0)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 51)) + + type S = (x: T) => T["k"]; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) + + type G = (x: A) => "c" | G | number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 8, 14)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 10, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 11, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : Symbol(inferenceConstraintMethod, Decl(relationCycleNonMonotoneCheckOrder.ts, 12, 1)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 51)) + + type S = { m(x: T): T["k"] }; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 30)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) + + type G = { m(x: A): "c" | G | number }; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 14)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 17)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 21, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 22, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : Symbol(inferenceConstraintMutual, Decl(relationCycleNonMonotoneCheckOrder.ts, 23, 1)) + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 24)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 17)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 38)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type S1 = (x: T) => T["k"]; +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) + + type G1 = (x: A1) => "c" | G2; +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 15)) +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 24)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 17)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 38)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type S2 = (x: T) => T["k"]; +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) + + type G2 = (x: A2) => "d" | G1; +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 37, 15)) +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let s1: S1; +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) + + declare let s2: S2; +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) + + let g1: G1 = s1; +>g1 : Symbol(g1, Decl(relationCycleNonMonotoneCheckOrder.ts, 41, 7)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) + + let g2: G2 = s2; +>g2 : Symbol(g2, Decl(relationCycleNonMonotoneCheckOrder.ts, 42, 7)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) + + declare let r1: S1 extends G1 ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 43, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let r2: S2 extends G2 ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 44, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : Symbol(discriminated, Decl(relationCycleNonMonotoneCheckOrder.ts, 45, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 68)) + + declare let r1: Src extends Tgt ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 58, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 59, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : Symbol(excessPropertyDiscriminant, Decl(relationCycleNonMonotoneCheckOrder.ts, 60, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 68)) + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 18)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 31)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 39)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 55)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + declare let src: Src; +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + let o: Outer = { e: src, w: 1 }; +>o : Symbol(o, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 7)) +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 20)) +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 28)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 74, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : Symbol(strictArity, Decl(relationCycleNonMonotoneCheckOrder.ts, 75, 1)) + + type P = { f: F | G; z: number }; +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 14)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 24)) + + type Q = { f: G; z: 1 }; +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 14)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 20)) + + type F = (x?: P) => 1; +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 14)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) + + type G = (x: Q | undefined) => number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 14)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + type WP = { a: P; b: string }; +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 15)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>b : Symbol(b, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 21)) + + type WQ = { a: Q }; +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 87, 15)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) + + let a1 = [f, g]; +>a1 : Symbol(a1, Decl(relationCycleNonMonotoneCheckOrder.ts, 90, 7)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) + + let a2 = [wp, wq]; +>a2 : Symbol(a2, Decl(relationCycleNonMonotoneCheckOrder.ts, 91, 7)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..ae7cfe7fe54a9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).types @@ -0,0 +1,292 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : typeof inferenceConstraint + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = (x: T) => T["k"]; +>S : S +>x : T + + type G = (x: A) => "c" | G | number; +>G : G +>x : A + + declare let r1: S extends G ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : typeof inferenceConstraintMethod + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = { m(x: T): T["k"] }; +>S : S +>m : (x: T) => T["k"] +>x : T + + type G = { m(x: A): "c" | G | number }; +>G : G +>m : (x: A) => "c" | G | number +>x : A + + declare let r1: S extends G ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : typeof inferenceConstraintMutual + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : A1 +>k : "c" | undefined +>f : G2 | S2 + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : C1 +>s : string +>f : G2 + + type S1 = (x: T) => T["k"]; +>S1 : S1 +>x : T + + type G1 = (x: A1) => "c" | G2; +>G1 : G1 +>x : A1 + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : A2 +>k : "d" | undefined +>f : G1 | S1 + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : C2 +>s : string +>f : G1 + + type S2 = (x: T) => T["k"]; +>S2 : S2 +>x : T + + type G2 = (x: A2) => "d" | G1; +>G2 : G2 +>x : A2 + + declare let s1: S1; +>s1 : S1 + + declare let s2: S2; +>s2 : S2 + + let g1: G1 = s1; +>g1 : G1 +>s1 : S1 + + let g2: G2 = s2; +>g2 : G2 +>s2 : S2 + + declare let r1: S1 extends G1 ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: S2 extends G2 ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : typeof discriminated + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + declare let r1: Src extends Tgt ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : typeof excessPropertyDiscriminant + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Outer +>e : "z" +>e : Tgt +>w : number +>e : Src + + declare let src: Src; +>src : Src + + let o: Outer = { e: src, w: 1 }; +>o : Outer +>{ e: src, w: 1 } : { e: Src; w: number; } +>e : Src +>src : Src +>w : number +>1 : 1 + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : typeof strictArity + + type P = { f: F | G; z: number }; +>P : P +>f : F | G +>z : number + + type Q = { f: G; z: 1 }; +>Q : Q +>f : G +>z : 1 + + type F = (x?: P) => 1; +>F : F +>x : P | undefined + + type G = (x: Q | undefined) => number; +>G : G +>x : Q | undefined + + type WP = { a: P; b: string }; +>WP : WP +>a : P +>b : string + + type WQ = { a: Q }; +>WQ : WQ +>a : Q + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : F +>g : G +>wp : WP +>wq : WQ + + let a1 = [f, g]; +>a1 : G[] +>[f, g] : G[] +>f : F +>g : G + + let a2 = [wp, wq]; +>a2 : (WP | WQ)[] +>[wp, wq] : (WP | WQ)[] +>wp : WP +>wq : WQ +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..286101cc10b43 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,107 @@ +relationCycleNonMonotoneCheckOrder.ts(42,9): error TS2322: Type 'S1' is not assignable to type 'G1'. + Type '"c" | undefined' is not assignable to type '"c" | G2'. + Type 'undefined' is not assignable to type '"c" | G2'. +relationCycleNonMonotoneCheckOrder.ts(74,30): error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + + +==== relationCycleNonMonotoneCheckOrder.ts (2 errors) ==== + // 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint + // 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to + // 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' + // whether or not 'A' was compared to 'C' first. + namespace inferenceConstraint { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = (x: T) => T["k"]; + type G = (x: A) => "c" | G | number; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // As above, with method signatures, which are compared bivariantly. + namespace inferenceConstraintMethod { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = { m(x: T): T["k"] }; + type G = { m(x: A): "c" | G | number }; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the + // reverse, so no answer is consistent for both. Each is answered as if + // compared first, assuming itself while relating the other, regardless + // of which assignment is checked first. + namespace inferenceConstraintMutual { + type A1 = { k?: "c"; f: S2 | G2 }; + type C1 = { [s: string]: "c" | G2; f: G2 }; + type S1 = (x: T) => T["k"]; + type G1 = (x: A1) => "c" | G2; + type A2 = { k?: "d"; f: S1 | G1 }; + type C2 = { [s: string]: "d" | G1; f: G1 }; + type S2 = (x: T) => T["k"]; + type G2 = (x: A2) => "d" | G1; + + declare let s1: S1; + declare let s2: S2; + let g1: G1 = s1; + ~~ +!!! error TS2322: Type 'S1' is not assignable to type 'G1'. +!!! error TS2322: Type '"c" | undefined' is not assignable to type '"c" | G2'. +!!! error TS2322: Type 'undefined' is not assignable to type '"c" | G2'. + let g2: G2 = s2; + declare let r1: S1 extends G1 ? true : false; + declare let r2: S2 extends G2 ? true : false; + } + + // 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member + // '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and + // relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on + // 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' + // first. + namespace discriminated { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + + declare let r1: Src extends Tgt ? true : false; + declare let r2: X extends Y ? true : false; + } + + // The excess property check of the object literal keeps the members of + // 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only + // if 'Src' relates to 'Tgt' as above. + namespace excessPropertyDiscriminant { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; + + declare let src: Src; + let o: Outer = { e: src, w: 1 }; + ~ +!!! error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + declare let r2: X extends Y ? true : false; + } + + // Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its + // optional parameter relates only if 'P' is not a strict subtype of 'Q', + // and relating 'P' to 'Q' compares 'F' to 'G' again before failing on + // 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. + namespace strictArity { + type P = { f: F | G; z: number }; + type Q = { f: G; z: 1 }; + type F = (x?: P) => 1; + type G = (x: Q | undefined) => number; + type WP = { a: P; b: string }; + type WQ = { a: Q }; + + declare let f: F, g: G, wp: WP, wq: WQ; + let a1 = [f, g]; + let a2 = [wp, wq]; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..3bc451c9c78bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).symbols @@ -0,0 +1,361 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : Symbol(inferenceConstraint, Decl(relationCycleNonMonotoneCheckOrder.ts, 0, 0)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 51)) + + type S = (x: T) => T["k"]; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) + + type G = (x: A) => "c" | G | number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 8, 14)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 10, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 11, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : Symbol(inferenceConstraintMethod, Decl(relationCycleNonMonotoneCheckOrder.ts, 12, 1)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 51)) + + type S = { m(x: T): T["k"] }; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 30)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) + + type G = { m(x: A): "c" | G | number }; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 14)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 17)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 21, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 22, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : Symbol(inferenceConstraintMutual, Decl(relationCycleNonMonotoneCheckOrder.ts, 23, 1)) + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 24)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 17)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 38)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type S1 = (x: T) => T["k"]; +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) + + type G1 = (x: A1) => "c" | G2; +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 15)) +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 24)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 17)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 38)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type S2 = (x: T) => T["k"]; +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) + + type G2 = (x: A2) => "d" | G1; +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 37, 15)) +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let s1: S1; +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) + + declare let s2: S2; +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) + + let g1: G1 = s1; +>g1 : Symbol(g1, Decl(relationCycleNonMonotoneCheckOrder.ts, 41, 7)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) + + let g2: G2 = s2; +>g2 : Symbol(g2, Decl(relationCycleNonMonotoneCheckOrder.ts, 42, 7)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) + + declare let r1: S1 extends G1 ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 43, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let r2: S2 extends G2 ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 44, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : Symbol(discriminated, Decl(relationCycleNonMonotoneCheckOrder.ts, 45, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 68)) + + declare let r1: Src extends Tgt ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 58, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 59, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : Symbol(excessPropertyDiscriminant, Decl(relationCycleNonMonotoneCheckOrder.ts, 60, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 68)) + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 18)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 31)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 39)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 55)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + declare let src: Src; +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + let o: Outer = { e: src, w: 1 }; +>o : Symbol(o, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 7)) +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 20)) +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 28)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 74, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : Symbol(strictArity, Decl(relationCycleNonMonotoneCheckOrder.ts, 75, 1)) + + type P = { f: F | G; z: number }; +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 14)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 24)) + + type Q = { f: G; z: 1 }; +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 14)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 20)) + + type F = (x?: P) => 1; +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 14)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) + + type G = (x: Q | undefined) => number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 14)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + type WP = { a: P; b: string }; +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 15)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>b : Symbol(b, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 21)) + + type WQ = { a: Q }; +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 87, 15)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) + + let a1 = [f, g]; +>a1 : Symbol(a1, Decl(relationCycleNonMonotoneCheckOrder.ts, 90, 7)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) + + let a2 = [wp, wq]; +>a2 : Symbol(a2, Decl(relationCycleNonMonotoneCheckOrder.ts, 91, 7)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..41b84c9efc3b0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).types @@ -0,0 +1,292 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : typeof inferenceConstraint + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = (x: T) => T["k"]; +>S : S +>x : T + + type G = (x: A) => "c" | G | number; +>G : G +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : typeof inferenceConstraintMethod + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = { m(x: T): T["k"] }; +>S : S +>m : (x: T) => T["k"] +>x : T + + type G = { m(x: A): "c" | G | number }; +>G : G +>m : (x: A) => "c" | G | number +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : typeof inferenceConstraintMutual + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : A1 +>k : "c" | undefined +>f : G2 | S2 + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : C1 +>s : string +>f : G2 + + type S1 = (x: T) => T["k"]; +>S1 : S1 +>x : T + + type G1 = (x: A1) => "c" | G2; +>G1 : G1 +>x : A1 + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : A2 +>k : "d" | undefined +>f : G1 | S1 + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : C2 +>s : string +>f : G1 + + type S2 = (x: T) => T["k"]; +>S2 : S2 +>x : T + + type G2 = (x: A2) => "d" | G1; +>G2 : G2 +>x : A2 + + declare let s1: S1; +>s1 : S1 + + declare let s2: S2; +>s2 : S2 + + let g1: G1 = s1; +>g1 : G1 +>s1 : S1 + + let g2: G2 = s2; +>g2 : G2 +>s2 : S2 + + declare let r1: S1 extends G1 ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: S2 extends G2 ? true : false; +>r2 : true +>true : true +>false : false +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : typeof discriminated + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + declare let r1: Src extends Tgt ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : typeof excessPropertyDiscriminant + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Outer +>e : "z" +>e : Tgt +>w : number +>e : Src + + declare let src: Src; +>src : Src + + let o: Outer = { e: src, w: 1 }; +>o : Outer +>{ e: src, w: 1 } : { e: Src; w: number; } +>e : Src +>src : Src +>w : number +>1 : 1 + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : typeof strictArity + + type P = { f: F | G; z: number }; +>P : P +>f : F | G +>z : number + + type Q = { f: G; z: 1 }; +>Q : Q +>f : G +>z : 1 + + type F = (x?: P) => 1; +>F : F +>x : P | undefined + + type G = (x: Q | undefined) => number; +>G : G +>x : Q | undefined + + type WP = { a: P; b: string }; +>WP : WP +>a : P +>b : string + + type WQ = { a: Q }; +>WQ : WQ +>a : Q + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : F +>g : G +>wp : WP +>wq : WQ + + let a1 = [f, g]; +>a1 : G[] +>[f, g] : G[] +>f : F +>g : G + + let a2 = [wp, wq]; +>a2 : (WP | WQ)[] +>[wp, wq] : (WP | WQ)[] +>wp : WP +>wq : WQ +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..286101cc10b43 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,107 @@ +relationCycleNonMonotoneCheckOrder.ts(42,9): error TS2322: Type 'S1' is not assignable to type 'G1'. + Type '"c" | undefined' is not assignable to type '"c" | G2'. + Type 'undefined' is not assignable to type '"c" | G2'. +relationCycleNonMonotoneCheckOrder.ts(74,30): error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + + +==== relationCycleNonMonotoneCheckOrder.ts (2 errors) ==== + // 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint + // 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to + // 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' + // whether or not 'A' was compared to 'C' first. + namespace inferenceConstraint { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = (x: T) => T["k"]; + type G = (x: A) => "c" | G | number; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // As above, with method signatures, which are compared bivariantly. + namespace inferenceConstraintMethod { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = { m(x: T): T["k"] }; + type G = { m(x: A): "c" | G | number }; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the + // reverse, so no answer is consistent for both. Each is answered as if + // compared first, assuming itself while relating the other, regardless + // of which assignment is checked first. + namespace inferenceConstraintMutual { + type A1 = { k?: "c"; f: S2 | G2 }; + type C1 = { [s: string]: "c" | G2; f: G2 }; + type S1 = (x: T) => T["k"]; + type G1 = (x: A1) => "c" | G2; + type A2 = { k?: "d"; f: S1 | G1 }; + type C2 = { [s: string]: "d" | G1; f: G1 }; + type S2 = (x: T) => T["k"]; + type G2 = (x: A2) => "d" | G1; + + declare let s1: S1; + declare let s2: S2; + let g1: G1 = s1; + ~~ +!!! error TS2322: Type 'S1' is not assignable to type 'G1'. +!!! error TS2322: Type '"c" | undefined' is not assignable to type '"c" | G2'. +!!! error TS2322: Type 'undefined' is not assignable to type '"c" | G2'. + let g2: G2 = s2; + declare let r1: S1 extends G1 ? true : false; + declare let r2: S2 extends G2 ? true : false; + } + + // 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member + // '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and + // relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on + // 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' + // first. + namespace discriminated { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + + declare let r1: Src extends Tgt ? true : false; + declare let r2: X extends Y ? true : false; + } + + // The excess property check of the object literal keeps the members of + // 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only + // if 'Src' relates to 'Tgt' as above. + namespace excessPropertyDiscriminant { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; + + declare let src: Src; + let o: Outer = { e: src, w: 1 }; + ~ +!!! error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + declare let r2: X extends Y ? true : false; + } + + // Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its + // optional parameter relates only if 'P' is not a strict subtype of 'Q', + // and relating 'P' to 'Q' compares 'F' to 'G' again before failing on + // 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. + namespace strictArity { + type P = { f: F | G; z: number }; + type Q = { f: G; z: 1 }; + type F = (x?: P) => 1; + type G = (x: Q | undefined) => number; + type WP = { a: P; b: string }; + type WQ = { a: Q }; + + declare let f: F, g: G, wp: WP, wq: WQ; + let a1 = [f, g]; + let a2 = [wp, wq]; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3bc451c9c78bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,361 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : Symbol(inferenceConstraint, Decl(relationCycleNonMonotoneCheckOrder.ts, 0, 0)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 51)) + + type S = (x: T) => T["k"]; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) + + type G = (x: A) => "c" | G | number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 8, 14)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 10, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 11, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : Symbol(inferenceConstraintMethod, Decl(relationCycleNonMonotoneCheckOrder.ts, 12, 1)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 51)) + + type S = { m(x: T): T["k"] }; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 30)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) + + type G = { m(x: A): "c" | G | number }; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 14)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 17)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 21, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 22, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : Symbol(inferenceConstraintMutual, Decl(relationCycleNonMonotoneCheckOrder.ts, 23, 1)) + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 24)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 17)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 38)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type S1 = (x: T) => T["k"]; +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) + + type G1 = (x: A1) => "c" | G2; +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 15)) +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 24)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 17)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 38)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type S2 = (x: T) => T["k"]; +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) + + type G2 = (x: A2) => "d" | G1; +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 37, 15)) +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let s1: S1; +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) + + declare let s2: S2; +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) + + let g1: G1 = s1; +>g1 : Symbol(g1, Decl(relationCycleNonMonotoneCheckOrder.ts, 41, 7)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) + + let g2: G2 = s2; +>g2 : Symbol(g2, Decl(relationCycleNonMonotoneCheckOrder.ts, 42, 7)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) + + declare let r1: S1 extends G1 ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 43, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let r2: S2 extends G2 ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 44, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : Symbol(discriminated, Decl(relationCycleNonMonotoneCheckOrder.ts, 45, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 68)) + + declare let r1: Src extends Tgt ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 58, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 59, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : Symbol(excessPropertyDiscriminant, Decl(relationCycleNonMonotoneCheckOrder.ts, 60, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 68)) + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 18)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 31)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 39)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 55)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + declare let src: Src; +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + let o: Outer = { e: src, w: 1 }; +>o : Symbol(o, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 7)) +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 20)) +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 28)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 74, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : Symbol(strictArity, Decl(relationCycleNonMonotoneCheckOrder.ts, 75, 1)) + + type P = { f: F | G; z: number }; +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 14)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 24)) + + type Q = { f: G; z: 1 }; +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 14)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 20)) + + type F = (x?: P) => 1; +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 14)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) + + type G = (x: Q | undefined) => number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 14)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + type WP = { a: P; b: string }; +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 15)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>b : Symbol(b, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 21)) + + type WQ = { a: Q }; +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 87, 15)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) + + let a1 = [f, g]; +>a1 : Symbol(a1, Decl(relationCycleNonMonotoneCheckOrder.ts, 90, 7)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) + + let a2 = [wp, wq]; +>a2 : Symbol(a2, Decl(relationCycleNonMonotoneCheckOrder.ts, 91, 7)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..55c0f3952ae35 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,292 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : typeof inferenceConstraint + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = (x: T) => T["k"]; +>S : S +>x : T + + type G = (x: A) => "c" | G | number; +>G : G +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : typeof inferenceConstraintMethod + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = { m(x: T): T["k"] }; +>S : S +>m : (x: T) => T["k"] +>x : T + + type G = { m(x: A): "c" | G | number }; +>G : G +>m : (x: A) => "c" | G | number +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : typeof inferenceConstraintMutual + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : A1 +>k : "c" | undefined +>f : G2 | S2 + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : C1 +>s : string +>f : G2 + + type S1 = (x: T) => T["k"]; +>S1 : S1 +>x : T + + type G1 = (x: A1) => "c" | G2; +>G1 : G1 +>x : A1 + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : A2 +>k : "d" | undefined +>f : G1 | S1 + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : C2 +>s : string +>f : G1 + + type S2 = (x: T) => T["k"]; +>S2 : S2 +>x : T + + type G2 = (x: A2) => "d" | G1; +>G2 : G2 +>x : A2 + + declare let s1: S1; +>s1 : S1 + + declare let s2: S2; +>s2 : S2 + + let g1: G1 = s1; +>g1 : G1 +>s1 : S1 + + let g2: G2 = s2; +>g2 : G2 +>s2 : S2 + + declare let r1: S1 extends G1 ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: S2 extends G2 ? true : false; +>r2 : true +>true : true +>false : false +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : typeof discriminated + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + declare let r1: Src extends Tgt ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : typeof excessPropertyDiscriminant + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Outer +>e : "z" +>e : Tgt +>w : number +>e : Src + + declare let src: Src; +>src : Src + + let o: Outer = { e: src, w: 1 }; +>o : Outer +>{ e: src, w: 1 } : { e: Src; w: number; } +>e : Src +>src : Src +>w : number +>1 : 1 + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : typeof strictArity + + type P = { f: F | G; z: number }; +>P : P +>f : F | G +>z : number + + type Q = { f: G; z: 1 }; +>Q : Q +>f : G +>z : 1 + + type F = (x?: P) => 1; +>F : F +>x : P | undefined + + type G = (x: Q | undefined) => number; +>G : G +>x : Q | undefined + + type WP = { a: P; b: string }; +>WP : WP +>a : P +>b : string + + type WQ = { a: Q }; +>WQ : WQ +>a : Q + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : F +>g : G +>wp : WP +>wq : WQ + + let a1 = [f, g]; +>a1 : (F | G)[] +>[f, g] : (F | G)[] +>f : F +>g : G + + let a2 = [wp, wq]; +>a2 : (WP | WQ)[] +>[wp, wq] : (WP | WQ)[] +>wp : WP +>wq : WQ +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.symbols b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.symbols new file mode 100644 index 0000000000000..cdf23cc04d684 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/relationDeeplyNestedCheckOrder.ts] //// + +=== relationDeeplyNestedCheckOrder.ts === +// Relating 'B<{ a: string }>' to 'B<{ a: "lit" }>' eventually relates 'string' +// to '"lit"' through 'm0.m1.a.m0.m1', but only after measuring the variances +// of 'A', which gives up on deeply nested types. TypeScript reports an error +// for the 'B' assignment only when it is checked before the 'A' assignment; +// the result must not depend on which is checked first. + +type A = { m0: (x: B) => void; m1: { [K in keyof T]: B } }; +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>m0 : Symbol(m0, Decl(relationDeeplyNestedCheckOrder.ts, 6, 13)) +>x : Symbol(x, Decl(relationDeeplyNestedCheckOrder.ts, 6, 19)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>m1 : Symbol(m1, Decl(relationDeeplyNestedCheckOrder.ts, 6, 36)) +>K : Symbol(K, Decl(relationDeeplyNestedCheckOrder.ts, 6, 44)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>K : Symbol(K, Decl(relationDeeplyNestedCheckOrder.ts, 6, 44)) + +type B = { m0: A }; +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 7, 7)) +>m0 : Symbol(m0, Decl(relationDeeplyNestedCheckOrder.ts, 7, 13)) +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 7, 7)) + +declare let a1: A<{ a: string }>, a2: A<{ a: "lit" }>; +>a1 : Symbol(a1, Decl(relationDeeplyNestedCheckOrder.ts, 9, 11)) +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 9, 19)) +>a2 : Symbol(a2, Decl(relationDeeplyNestedCheckOrder.ts, 9, 33)) +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 9, 41)) + +declare let b1: B<{ a: string }>, b2: B<{ a: "lit" }>; +>b1 : Symbol(b1, Decl(relationDeeplyNestedCheckOrder.ts, 10, 11)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 10, 19)) +>b2 : Symbol(b2, Decl(relationDeeplyNestedCheckOrder.ts, 10, 33)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 10, 41)) + +a2 = a1; +>a2 : Symbol(a2, Decl(relationDeeplyNestedCheckOrder.ts, 9, 33)) +>a1 : Symbol(a1, Decl(relationDeeplyNestedCheckOrder.ts, 9, 11)) + +b2 = b1; +>b2 : Symbol(b2, Decl(relationDeeplyNestedCheckOrder.ts, 10, 33)) +>b1 : Symbol(b1, Decl(relationDeeplyNestedCheckOrder.ts, 10, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.types b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.types new file mode 100644 index 0000000000000..fedd3a84c64f9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/relationDeeplyNestedCheckOrder.ts] //// + +=== relationDeeplyNestedCheckOrder.ts === +// Relating 'B<{ a: string }>' to 'B<{ a: "lit" }>' eventually relates 'string' +// to '"lit"' through 'm0.m1.a.m0.m1', but only after measuring the variances +// of 'A', which gives up on deeply nested types. TypeScript reports an error +// for the 'B' assignment only when it is checked before the 'A' assignment; +// the result must not depend on which is checked first. + +type A = { m0: (x: B) => void; m1: { [K in keyof T]: B } }; +>A : A +>m0 : (x: B) => void +>x : B +>m1 : { [K in keyof T]: B; } + +type B = { m0: A }; +>B : B +>m0 : A + +declare let a1: A<{ a: string }>, a2: A<{ a: "lit" }>; +>a1 : A<{ a: string; }> +>a : string +>a2 : A<{ a: "lit"; }> +>a : "lit" + +declare let b1: B<{ a: string }>, b2: B<{ a: "lit" }>; +>b1 : B<{ a: string; }> +>a : string +>b2 : B<{ a: "lit"; }> +>a : "lit" + +a2 = a1; +>a2 = a1 : A<{ a: string; }> +>a2 : A<{ a: "lit"; }> +>a1 : A<{ a: string; }> + +b2 = b1; +>b2 = b1 : B<{ a: string; }> +>b2 : B<{ a: "lit"; }> +>b1 : B<{ a: string; }> + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..89aebb5fd9f9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,1217 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>next : Symbol(I0.next, Decl(relationDepthSharedCheckOrder.ts, 6, 14)) +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) + +interface J0 { next: J1 } +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) +>next : Symbol(J0.next, Decl(relationDepthSharedCheckOrder.ts, 7, 14)) +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) + +interface I1 { next: I2 } +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) +>next : Symbol(I1.next, Decl(relationDepthSharedCheckOrder.ts, 8, 14)) +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) + +interface J1 { next: J2 } +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) +>next : Symbol(J1.next, Decl(relationDepthSharedCheckOrder.ts, 9, 14)) +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) + +interface I2 { next: I3 } +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) +>next : Symbol(I2.next, Decl(relationDepthSharedCheckOrder.ts, 10, 14)) +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) + +interface J2 { next: J3 } +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) +>next : Symbol(J2.next, Decl(relationDepthSharedCheckOrder.ts, 11, 14)) +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) + +interface I3 { next: I4 } +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) +>next : Symbol(I3.next, Decl(relationDepthSharedCheckOrder.ts, 12, 14)) +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) + +interface J3 { next: J4 } +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) +>next : Symbol(J3.next, Decl(relationDepthSharedCheckOrder.ts, 13, 14)) +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) + +interface I4 { next: I5 } +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) +>next : Symbol(I4.next, Decl(relationDepthSharedCheckOrder.ts, 14, 14)) +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) + +interface J4 { next: J5 } +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) +>next : Symbol(J4.next, Decl(relationDepthSharedCheckOrder.ts, 15, 14)) +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) + +interface I5 { next: I6 } +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) +>next : Symbol(I5.next, Decl(relationDepthSharedCheckOrder.ts, 16, 14)) +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) + +interface J5 { next: J6 } +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) +>next : Symbol(J5.next, Decl(relationDepthSharedCheckOrder.ts, 17, 14)) +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) + +interface I6 { next: I7 } +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) +>next : Symbol(I6.next, Decl(relationDepthSharedCheckOrder.ts, 18, 14)) +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) + +interface J6 { next: J7 } +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) +>next : Symbol(J6.next, Decl(relationDepthSharedCheckOrder.ts, 19, 14)) +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) + +interface I7 { next: I8 } +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) +>next : Symbol(I7.next, Decl(relationDepthSharedCheckOrder.ts, 20, 14)) +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) + +interface J7 { next: J8 } +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) +>next : Symbol(J7.next, Decl(relationDepthSharedCheckOrder.ts, 21, 14)) +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) + +interface I8 { next: I9 } +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) +>next : Symbol(I8.next, Decl(relationDepthSharedCheckOrder.ts, 22, 14)) +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) + +interface J8 { next: J9 } +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) +>next : Symbol(J8.next, Decl(relationDepthSharedCheckOrder.ts, 23, 14)) +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) + +interface I9 { next: I10 } +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) +>next : Symbol(I9.next, Decl(relationDepthSharedCheckOrder.ts, 24, 14)) +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) + +interface J9 { next: J10 } +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) +>next : Symbol(J9.next, Decl(relationDepthSharedCheckOrder.ts, 25, 14)) +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) + +interface I10 { next: I11 } +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) +>next : Symbol(I10.next, Decl(relationDepthSharedCheckOrder.ts, 26, 15)) +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) + +interface J10 { next: J11 } +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) +>next : Symbol(J10.next, Decl(relationDepthSharedCheckOrder.ts, 27, 15)) +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) + +interface I11 { next: I12 } +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) +>next : Symbol(I11.next, Decl(relationDepthSharedCheckOrder.ts, 28, 15)) +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) + +interface J11 { next: J12 } +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) +>next : Symbol(J11.next, Decl(relationDepthSharedCheckOrder.ts, 29, 15)) +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) + +interface I12 { next: I13 } +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) +>next : Symbol(I12.next, Decl(relationDepthSharedCheckOrder.ts, 30, 15)) +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) + +interface J12 { next: J13 } +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) +>next : Symbol(J12.next, Decl(relationDepthSharedCheckOrder.ts, 31, 15)) +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) + +interface I13 { next: I14 } +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) +>next : Symbol(I13.next, Decl(relationDepthSharedCheckOrder.ts, 32, 15)) +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) + +interface J13 { next: J14 } +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) +>next : Symbol(J13.next, Decl(relationDepthSharedCheckOrder.ts, 33, 15)) +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) + +interface I14 { next: I15 } +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) +>next : Symbol(I14.next, Decl(relationDepthSharedCheckOrder.ts, 34, 15)) +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) + +interface J14 { next: J15 } +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) +>next : Symbol(J14.next, Decl(relationDepthSharedCheckOrder.ts, 35, 15)) +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) + +interface I15 { next: I16 } +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) +>next : Symbol(I15.next, Decl(relationDepthSharedCheckOrder.ts, 36, 15)) +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) + +interface J15 { next: J16 } +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) +>next : Symbol(J15.next, Decl(relationDepthSharedCheckOrder.ts, 37, 15)) +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) + +interface I16 { next: I17 } +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) +>next : Symbol(I16.next, Decl(relationDepthSharedCheckOrder.ts, 38, 15)) +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) + +interface J16 { next: J17 } +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) +>next : Symbol(J16.next, Decl(relationDepthSharedCheckOrder.ts, 39, 15)) +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) + +interface I17 { next: I18 } +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) +>next : Symbol(I17.next, Decl(relationDepthSharedCheckOrder.ts, 40, 15)) +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) + +interface J17 { next: J18 } +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) +>next : Symbol(J17.next, Decl(relationDepthSharedCheckOrder.ts, 41, 15)) +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) + +interface I18 { next: I19 } +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) +>next : Symbol(I18.next, Decl(relationDepthSharedCheckOrder.ts, 42, 15)) +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) + +interface J18 { next: J19 } +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) +>next : Symbol(J18.next, Decl(relationDepthSharedCheckOrder.ts, 43, 15)) +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) + +interface I19 { next: I20 } +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) +>next : Symbol(I19.next, Decl(relationDepthSharedCheckOrder.ts, 44, 15)) +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) + +interface J19 { next: J20 } +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) +>next : Symbol(J19.next, Decl(relationDepthSharedCheckOrder.ts, 45, 15)) +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) + +interface I20 { next: I21 } +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) +>next : Symbol(I20.next, Decl(relationDepthSharedCheckOrder.ts, 46, 15)) +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) + +interface J20 { next: J21 } +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) +>next : Symbol(J20.next, Decl(relationDepthSharedCheckOrder.ts, 47, 15)) +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) + +interface I21 { next: I22 } +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) +>next : Symbol(I21.next, Decl(relationDepthSharedCheckOrder.ts, 48, 15)) +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) + +interface J21 { next: J22 } +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) +>next : Symbol(J21.next, Decl(relationDepthSharedCheckOrder.ts, 49, 15)) +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) + +interface I22 { next: I23 } +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) +>next : Symbol(I22.next, Decl(relationDepthSharedCheckOrder.ts, 50, 15)) +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) + +interface J22 { next: J23 } +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) +>next : Symbol(J22.next, Decl(relationDepthSharedCheckOrder.ts, 51, 15)) +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) + +interface I23 { next: I24 } +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) +>next : Symbol(I23.next, Decl(relationDepthSharedCheckOrder.ts, 52, 15)) +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) + +interface J23 { next: J24 } +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) +>next : Symbol(J23.next, Decl(relationDepthSharedCheckOrder.ts, 53, 15)) +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) + +interface I24 { next: I25 } +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) +>next : Symbol(I24.next, Decl(relationDepthSharedCheckOrder.ts, 54, 15)) +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) + +interface J24 { next: J25 } +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) +>next : Symbol(J24.next, Decl(relationDepthSharedCheckOrder.ts, 55, 15)) +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) + +interface I25 { next: I26 } +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) +>next : Symbol(I25.next, Decl(relationDepthSharedCheckOrder.ts, 56, 15)) +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) + +interface J25 { next: J26 } +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) +>next : Symbol(J25.next, Decl(relationDepthSharedCheckOrder.ts, 57, 15)) +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) + +interface I26 { next: I27 } +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) +>next : Symbol(I26.next, Decl(relationDepthSharedCheckOrder.ts, 58, 15)) +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) + +interface J26 { next: J27 } +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) +>next : Symbol(J26.next, Decl(relationDepthSharedCheckOrder.ts, 59, 15)) +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) + +interface I27 { next: I28 } +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) +>next : Symbol(I27.next, Decl(relationDepthSharedCheckOrder.ts, 60, 15)) +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) + +interface J27 { next: J28 } +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) +>next : Symbol(J27.next, Decl(relationDepthSharedCheckOrder.ts, 61, 15)) +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) + +interface I28 { next: I29 } +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) +>next : Symbol(I28.next, Decl(relationDepthSharedCheckOrder.ts, 62, 15)) +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) + +interface J28 { next: J29 } +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) +>next : Symbol(J28.next, Decl(relationDepthSharedCheckOrder.ts, 63, 15)) +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) + +interface I29 { next: I30 } +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) +>next : Symbol(I29.next, Decl(relationDepthSharedCheckOrder.ts, 64, 15)) +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) + +interface J29 { next: J30 } +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) +>next : Symbol(J29.next, Decl(relationDepthSharedCheckOrder.ts, 65, 15)) +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) + +interface I30 { next: I31 } +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) +>next : Symbol(I30.next, Decl(relationDepthSharedCheckOrder.ts, 66, 15)) +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) + +interface J30 { next: J31 } +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) +>next : Symbol(J30.next, Decl(relationDepthSharedCheckOrder.ts, 67, 15)) +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) + +interface I31 { next: I32 } +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) +>next : Symbol(I31.next, Decl(relationDepthSharedCheckOrder.ts, 68, 15)) +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) + +interface J31 { next: J32 } +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) +>next : Symbol(J31.next, Decl(relationDepthSharedCheckOrder.ts, 69, 15)) +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) + +interface I32 { next: I33 } +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) +>next : Symbol(I32.next, Decl(relationDepthSharedCheckOrder.ts, 70, 15)) +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) + +interface J32 { next: J33 } +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) +>next : Symbol(J32.next, Decl(relationDepthSharedCheckOrder.ts, 71, 15)) +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) + +interface I33 { next: I34 } +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) +>next : Symbol(I33.next, Decl(relationDepthSharedCheckOrder.ts, 72, 15)) +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) + +interface J33 { next: J34 } +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) +>next : Symbol(J33.next, Decl(relationDepthSharedCheckOrder.ts, 73, 15)) +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) + +interface I34 { next: I35 } +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) +>next : Symbol(I34.next, Decl(relationDepthSharedCheckOrder.ts, 74, 15)) +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) + +interface J34 { next: J35 } +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) +>next : Symbol(J34.next, Decl(relationDepthSharedCheckOrder.ts, 75, 15)) +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) + +interface I35 { next: I36 } +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) +>next : Symbol(I35.next, Decl(relationDepthSharedCheckOrder.ts, 76, 15)) +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) + +interface J35 { next: J36 } +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) +>next : Symbol(J35.next, Decl(relationDepthSharedCheckOrder.ts, 77, 15)) +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) + +interface I36 { next: I37 } +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) +>next : Symbol(I36.next, Decl(relationDepthSharedCheckOrder.ts, 78, 15)) +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) + +interface J36 { next: J37 } +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) +>next : Symbol(J36.next, Decl(relationDepthSharedCheckOrder.ts, 79, 15)) +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) + +interface I37 { next: I38 } +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) +>next : Symbol(I37.next, Decl(relationDepthSharedCheckOrder.ts, 80, 15)) +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) + +interface J37 { next: J38 } +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) +>next : Symbol(J37.next, Decl(relationDepthSharedCheckOrder.ts, 81, 15)) +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) + +interface I38 { next: I39 } +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) +>next : Symbol(I38.next, Decl(relationDepthSharedCheckOrder.ts, 82, 15)) +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) + +interface J38 { next: J39 } +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) +>next : Symbol(J38.next, Decl(relationDepthSharedCheckOrder.ts, 83, 15)) +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) + +interface I39 { next: I40 } +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) +>next : Symbol(I39.next, Decl(relationDepthSharedCheckOrder.ts, 84, 15)) +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) + +interface J39 { next: J40 } +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) +>next : Symbol(J39.next, Decl(relationDepthSharedCheckOrder.ts, 85, 15)) +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) + +interface I40 { next: I41 } +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) +>next : Symbol(I40.next, Decl(relationDepthSharedCheckOrder.ts, 86, 15)) +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) + +interface J40 { next: J41 } +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) +>next : Symbol(J40.next, Decl(relationDepthSharedCheckOrder.ts, 87, 15)) +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) + +interface I41 { next: I42 } +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) +>next : Symbol(I41.next, Decl(relationDepthSharedCheckOrder.ts, 88, 15)) +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) + +interface J41 { next: J42 } +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) +>next : Symbol(J41.next, Decl(relationDepthSharedCheckOrder.ts, 89, 15)) +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) + +interface I42 { next: I43 } +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) +>next : Symbol(I42.next, Decl(relationDepthSharedCheckOrder.ts, 90, 15)) +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) + +interface J42 { next: J43 } +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) +>next : Symbol(J42.next, Decl(relationDepthSharedCheckOrder.ts, 91, 15)) +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) + +interface I43 { next: I44 } +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) +>next : Symbol(I43.next, Decl(relationDepthSharedCheckOrder.ts, 92, 15)) +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) + +interface J43 { next: J44 } +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) +>next : Symbol(J43.next, Decl(relationDepthSharedCheckOrder.ts, 93, 15)) +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) + +interface I44 { next: I45 } +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) +>next : Symbol(I44.next, Decl(relationDepthSharedCheckOrder.ts, 94, 15)) +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) + +interface J44 { next: J45 } +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) +>next : Symbol(J44.next, Decl(relationDepthSharedCheckOrder.ts, 95, 15)) +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) + +interface I45 { next: I46 } +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) +>next : Symbol(I45.next, Decl(relationDepthSharedCheckOrder.ts, 96, 15)) +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) + +interface J45 { next: J46 } +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) +>next : Symbol(J45.next, Decl(relationDepthSharedCheckOrder.ts, 97, 15)) +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) + +interface I46 { next: I47 } +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) +>next : Symbol(I46.next, Decl(relationDepthSharedCheckOrder.ts, 98, 15)) +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) + +interface J46 { next: J47 } +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) +>next : Symbol(J46.next, Decl(relationDepthSharedCheckOrder.ts, 99, 15)) +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) + +interface I47 { next: I48 } +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) +>next : Symbol(I47.next, Decl(relationDepthSharedCheckOrder.ts, 100, 15)) +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) + +interface J47 { next: J48 } +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) +>next : Symbol(J47.next, Decl(relationDepthSharedCheckOrder.ts, 101, 15)) +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) + +interface I48 { next: I49 } +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) +>next : Symbol(I48.next, Decl(relationDepthSharedCheckOrder.ts, 102, 15)) +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) + +interface J48 { next: J49 } +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) +>next : Symbol(J48.next, Decl(relationDepthSharedCheckOrder.ts, 103, 15)) +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) + +interface I49 { next: I50 } +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) +>next : Symbol(I49.next, Decl(relationDepthSharedCheckOrder.ts, 104, 15)) +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) + +interface J49 { next: J50 } +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) +>next : Symbol(J49.next, Decl(relationDepthSharedCheckOrder.ts, 105, 15)) +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) + +interface I50 { next: I51 } +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) +>next : Symbol(I50.next, Decl(relationDepthSharedCheckOrder.ts, 106, 15)) +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) + +interface J50 { next: J51 } +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) +>next : Symbol(J50.next, Decl(relationDepthSharedCheckOrder.ts, 107, 15)) +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) + +interface I51 { next: I52 } +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) +>next : Symbol(I51.next, Decl(relationDepthSharedCheckOrder.ts, 108, 15)) +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) + +interface J51 { next: J52 } +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) +>next : Symbol(J51.next, Decl(relationDepthSharedCheckOrder.ts, 109, 15)) +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) + +interface I52 { next: I53 } +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) +>next : Symbol(I52.next, Decl(relationDepthSharedCheckOrder.ts, 110, 15)) +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) + +interface J52 { next: J53 } +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) +>next : Symbol(J52.next, Decl(relationDepthSharedCheckOrder.ts, 111, 15)) +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) + +interface I53 { next: I54 } +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) +>next : Symbol(I53.next, Decl(relationDepthSharedCheckOrder.ts, 112, 15)) +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) + +interface J53 { next: J54 } +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) +>next : Symbol(J53.next, Decl(relationDepthSharedCheckOrder.ts, 113, 15)) +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) + +interface I54 { next: I55 } +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) +>next : Symbol(I54.next, Decl(relationDepthSharedCheckOrder.ts, 114, 15)) +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) + +interface J54 { next: J55 } +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) +>next : Symbol(J54.next, Decl(relationDepthSharedCheckOrder.ts, 115, 15)) +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) + +interface I55 { next: I56 } +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) +>next : Symbol(I55.next, Decl(relationDepthSharedCheckOrder.ts, 116, 15)) +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) + +interface J55 { next: J56 } +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) +>next : Symbol(J55.next, Decl(relationDepthSharedCheckOrder.ts, 117, 15)) +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) + +interface I56 { next: I57 } +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) +>next : Symbol(I56.next, Decl(relationDepthSharedCheckOrder.ts, 118, 15)) +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) + +interface J56 { next: J57 } +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) +>next : Symbol(J56.next, Decl(relationDepthSharedCheckOrder.ts, 119, 15)) +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) + +interface I57 { next: I58 } +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) +>next : Symbol(I57.next, Decl(relationDepthSharedCheckOrder.ts, 120, 15)) +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) + +interface J57 { next: J58 } +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) +>next : Symbol(J57.next, Decl(relationDepthSharedCheckOrder.ts, 121, 15)) +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) + +interface I58 { next: I59 } +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) +>next : Symbol(I58.next, Decl(relationDepthSharedCheckOrder.ts, 122, 15)) +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) + +interface J58 { next: J59 } +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) +>next : Symbol(J58.next, Decl(relationDepthSharedCheckOrder.ts, 123, 15)) +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) + +interface I59 { next: I60 } +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) +>next : Symbol(I59.next, Decl(relationDepthSharedCheckOrder.ts, 124, 15)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) + +interface J59 { next: J60 } +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) +>next : Symbol(J59.next, Decl(relationDepthSharedCheckOrder.ts, 125, 15)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +interface I60 { next: I61 } +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>next : Symbol(I60.next, Decl(relationDepthSharedCheckOrder.ts, 126, 15)) +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) + +interface J60 { next: J61 } +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) +>next : Symbol(J60.next, Decl(relationDepthSharedCheckOrder.ts, 127, 15)) +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) + +interface I61 { next: I62 } +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) +>next : Symbol(I61.next, Decl(relationDepthSharedCheckOrder.ts, 128, 15)) +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) + +interface J61 { next: J62 } +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) +>next : Symbol(J61.next, Decl(relationDepthSharedCheckOrder.ts, 129, 15)) +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) + +interface I62 { next: I63 } +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) +>next : Symbol(I62.next, Decl(relationDepthSharedCheckOrder.ts, 130, 15)) +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) + +interface J62 { next: J63 } +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) +>next : Symbol(J62.next, Decl(relationDepthSharedCheckOrder.ts, 131, 15)) +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) + +interface I63 { next: I64 } +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) +>next : Symbol(I63.next, Decl(relationDepthSharedCheckOrder.ts, 132, 15)) +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) + +interface J63 { next: J64 } +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) +>next : Symbol(J63.next, Decl(relationDepthSharedCheckOrder.ts, 133, 15)) +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) + +interface I64 { next: I65 } +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) +>next : Symbol(I64.next, Decl(relationDepthSharedCheckOrder.ts, 134, 15)) +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) + +interface J64 { next: J65 } +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) +>next : Symbol(J64.next, Decl(relationDepthSharedCheckOrder.ts, 135, 15)) +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) + +interface I65 { next: I66 } +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) +>next : Symbol(I65.next, Decl(relationDepthSharedCheckOrder.ts, 136, 15)) +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) + +interface J65 { next: J66 } +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) +>next : Symbol(J65.next, Decl(relationDepthSharedCheckOrder.ts, 137, 15)) +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) + +interface I66 { next: I67 } +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) +>next : Symbol(I66.next, Decl(relationDepthSharedCheckOrder.ts, 138, 15)) +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) + +interface J66 { next: J67 } +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) +>next : Symbol(J66.next, Decl(relationDepthSharedCheckOrder.ts, 139, 15)) +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) + +interface I67 { next: I68 } +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) +>next : Symbol(I67.next, Decl(relationDepthSharedCheckOrder.ts, 140, 15)) +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) + +interface J67 { next: J68 } +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) +>next : Symbol(J67.next, Decl(relationDepthSharedCheckOrder.ts, 141, 15)) +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) + +interface I68 { next: I69 } +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) +>next : Symbol(I68.next, Decl(relationDepthSharedCheckOrder.ts, 142, 15)) +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) + +interface J68 { next: J69 } +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) +>next : Symbol(J68.next, Decl(relationDepthSharedCheckOrder.ts, 143, 15)) +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) + +interface I69 { next: I70 } +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) +>next : Symbol(I69.next, Decl(relationDepthSharedCheckOrder.ts, 144, 15)) +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) + +interface J69 { next: J70 } +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) +>next : Symbol(J69.next, Decl(relationDepthSharedCheckOrder.ts, 145, 15)) +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) + +interface I70 { next: I71 } +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) +>next : Symbol(I70.next, Decl(relationDepthSharedCheckOrder.ts, 146, 15)) +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) + +interface J70 { next: J71 } +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) +>next : Symbol(J70.next, Decl(relationDepthSharedCheckOrder.ts, 147, 15)) +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) + +interface I71 { next: I72 } +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) +>next : Symbol(I71.next, Decl(relationDepthSharedCheckOrder.ts, 148, 15)) +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) + +interface J71 { next: J72 } +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) +>next : Symbol(J71.next, Decl(relationDepthSharedCheckOrder.ts, 149, 15)) +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) + +interface I72 { next: I73 } +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) +>next : Symbol(I72.next, Decl(relationDepthSharedCheckOrder.ts, 150, 15)) +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) + +interface J72 { next: J73 } +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) +>next : Symbol(J72.next, Decl(relationDepthSharedCheckOrder.ts, 151, 15)) +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) + +interface I73 { next: I74 } +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) +>next : Symbol(I73.next, Decl(relationDepthSharedCheckOrder.ts, 152, 15)) +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) + +interface J73 { next: J74 } +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) +>next : Symbol(J73.next, Decl(relationDepthSharedCheckOrder.ts, 153, 15)) +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) + +interface I74 { next: I75 } +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) +>next : Symbol(I74.next, Decl(relationDepthSharedCheckOrder.ts, 154, 15)) +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) + +interface J74 { next: J75 } +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) +>next : Symbol(J74.next, Decl(relationDepthSharedCheckOrder.ts, 155, 15)) +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) + +interface I75 { next: I76 } +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) +>next : Symbol(I75.next, Decl(relationDepthSharedCheckOrder.ts, 156, 15)) +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) + +interface J75 { next: J76 } +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) +>next : Symbol(J75.next, Decl(relationDepthSharedCheckOrder.ts, 157, 15)) +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) + +interface I76 { next: I77 } +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) +>next : Symbol(I76.next, Decl(relationDepthSharedCheckOrder.ts, 158, 15)) +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) + +interface J76 { next: J77 } +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) +>next : Symbol(J76.next, Decl(relationDepthSharedCheckOrder.ts, 159, 15)) +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) + +interface I77 { next: I78 } +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) +>next : Symbol(I77.next, Decl(relationDepthSharedCheckOrder.ts, 160, 15)) +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) + +interface J77 { next: J78 } +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) +>next : Symbol(J77.next, Decl(relationDepthSharedCheckOrder.ts, 161, 15)) +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) + +interface I78 { next: I79 } +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) +>next : Symbol(I78.next, Decl(relationDepthSharedCheckOrder.ts, 162, 15)) +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) + +interface J78 { next: J79 } +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) +>next : Symbol(J78.next, Decl(relationDepthSharedCheckOrder.ts, 163, 15)) +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) + +interface I79 { next: I80 } +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) +>next : Symbol(I79.next, Decl(relationDepthSharedCheckOrder.ts, 164, 15)) +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) + +interface J79 { next: J80 } +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) +>next : Symbol(J79.next, Decl(relationDepthSharedCheckOrder.ts, 165, 15)) +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) + +interface I80 { next: I81 } +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) +>next : Symbol(I80.next, Decl(relationDepthSharedCheckOrder.ts, 166, 15)) +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) + +interface J80 { next: J81 } +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) +>next : Symbol(J80.next, Decl(relationDepthSharedCheckOrder.ts, 167, 15)) +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) + +interface I81 { next: I82 } +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) +>next : Symbol(I81.next, Decl(relationDepthSharedCheckOrder.ts, 168, 15)) +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) + +interface J81 { next: J82 } +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) +>next : Symbol(J81.next, Decl(relationDepthSharedCheckOrder.ts, 169, 15)) +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) + +interface I82 { next: I83 } +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) +>next : Symbol(I82.next, Decl(relationDepthSharedCheckOrder.ts, 170, 15)) +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) + +interface J82 { next: J83 } +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) +>next : Symbol(J82.next, Decl(relationDepthSharedCheckOrder.ts, 171, 15)) +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) + +interface I83 { next: I84 } +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) +>next : Symbol(I83.next, Decl(relationDepthSharedCheckOrder.ts, 172, 15)) +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) + +interface J83 { next: J84 } +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) +>next : Symbol(J83.next, Decl(relationDepthSharedCheckOrder.ts, 173, 15)) +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) + +interface I84 { next: I85 } +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) +>next : Symbol(I84.next, Decl(relationDepthSharedCheckOrder.ts, 174, 15)) +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) + +interface J84 { next: J85 } +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) +>next : Symbol(J84.next, Decl(relationDepthSharedCheckOrder.ts, 175, 15)) +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) + +interface I85 { next: I86 } +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) +>next : Symbol(I85.next, Decl(relationDepthSharedCheckOrder.ts, 176, 15)) +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) + +interface J85 { next: J86 } +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) +>next : Symbol(J85.next, Decl(relationDepthSharedCheckOrder.ts, 177, 15)) +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) + +interface I86 { next: I87 } +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) +>next : Symbol(I86.next, Decl(relationDepthSharedCheckOrder.ts, 178, 15)) +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) + +interface J86 { next: J87 } +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) +>next : Symbol(J86.next, Decl(relationDepthSharedCheckOrder.ts, 179, 15)) +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) + +interface I87 { next: I88 } +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) +>next : Symbol(I87.next, Decl(relationDepthSharedCheckOrder.ts, 180, 15)) +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) + +interface J87 { next: J88 } +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) +>next : Symbol(J87.next, Decl(relationDepthSharedCheckOrder.ts, 181, 15)) +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) + +interface I88 { next: I89 } +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) +>next : Symbol(I88.next, Decl(relationDepthSharedCheckOrder.ts, 182, 15)) +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) + +interface J88 { next: J89 } +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) +>next : Symbol(J88.next, Decl(relationDepthSharedCheckOrder.ts, 183, 15)) +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) + +interface I89 { next: I90 } +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) +>next : Symbol(I89.next, Decl(relationDepthSharedCheckOrder.ts, 184, 15)) +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) + +interface J89 { next: J90 } +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) +>next : Symbol(J89.next, Decl(relationDepthSharedCheckOrder.ts, 185, 15)) +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) + +interface I90 { next: I91 } +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) +>next : Symbol(I90.next, Decl(relationDepthSharedCheckOrder.ts, 186, 15)) +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) + +interface J90 { next: J91 } +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) +>next : Symbol(J90.next, Decl(relationDepthSharedCheckOrder.ts, 187, 15)) +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) + +interface I91 { next: I92 } +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) +>next : Symbol(I91.next, Decl(relationDepthSharedCheckOrder.ts, 188, 15)) +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) + +interface J91 { next: J92 } +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) +>next : Symbol(J91.next, Decl(relationDepthSharedCheckOrder.ts, 189, 15)) +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) + +interface I92 { next: I93 } +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) +>next : Symbol(I92.next, Decl(relationDepthSharedCheckOrder.ts, 190, 15)) +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) + +interface J92 { next: J93 } +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) +>next : Symbol(J92.next, Decl(relationDepthSharedCheckOrder.ts, 191, 15)) +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) + +interface I93 { next: I94 } +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) +>next : Symbol(I93.next, Decl(relationDepthSharedCheckOrder.ts, 192, 15)) +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) + +interface J93 { next: J94 } +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) +>next : Symbol(J93.next, Decl(relationDepthSharedCheckOrder.ts, 193, 15)) +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) + +interface I94 { next: I95 } +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) +>next : Symbol(I94.next, Decl(relationDepthSharedCheckOrder.ts, 194, 15)) +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) + +interface J94 { next: J95 } +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) +>next : Symbol(J94.next, Decl(relationDepthSharedCheckOrder.ts, 195, 15)) +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) + +interface I95 { next: I96 } +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) +>next : Symbol(I95.next, Decl(relationDepthSharedCheckOrder.ts, 196, 15)) +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) + +interface J95 { next: J96 } +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) +>next : Symbol(J95.next, Decl(relationDepthSharedCheckOrder.ts, 197, 15)) +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) + +interface I96 { next: I97 } +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) +>next : Symbol(I96.next, Decl(relationDepthSharedCheckOrder.ts, 198, 15)) +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) + +interface J96 { next: J97 } +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) +>next : Symbol(J96.next, Decl(relationDepthSharedCheckOrder.ts, 199, 15)) +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) + +interface I97 { next: I98 } +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) +>next : Symbol(I97.next, Decl(relationDepthSharedCheckOrder.ts, 200, 15)) +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) + +interface J97 { next: J98 } +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) +>next : Symbol(J97.next, Decl(relationDepthSharedCheckOrder.ts, 201, 15)) +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) + +interface I98 { next: I99 } +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) +>next : Symbol(I98.next, Decl(relationDepthSharedCheckOrder.ts, 202, 15)) +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) + +interface J98 { next: J99 } +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) +>next : Symbol(J98.next, Decl(relationDepthSharedCheckOrder.ts, 203, 15)) +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) + +interface I99 { next: I100 } +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) +>next : Symbol(I99.next, Decl(relationDepthSharedCheckOrder.ts, 204, 15)) +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) + +interface J99 { next: J100 } +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) +>next : Symbol(J99.next, Decl(relationDepthSharedCheckOrder.ts, 205, 15)) +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) + +interface I100 { next: I101 } +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) +>next : Symbol(I100.next, Decl(relationDepthSharedCheckOrder.ts, 206, 16)) +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) + +interface J100 { next: J101 } +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) +>next : Symbol(J100.next, Decl(relationDepthSharedCheckOrder.ts, 207, 16)) +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) + +interface I101 { next: I102 } +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) +>next : Symbol(I101.next, Decl(relationDepthSharedCheckOrder.ts, 208, 16)) +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) + +interface J101 { next: J102 } +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) +>next : Symbol(J101.next, Decl(relationDepthSharedCheckOrder.ts, 209, 16)) +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) + +interface I102 { next: I103 } +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) +>next : Symbol(I102.next, Decl(relationDepthSharedCheckOrder.ts, 210, 16)) +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) + +interface J102 { next: J103 } +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) +>next : Symbol(J102.next, Decl(relationDepthSharedCheckOrder.ts, 211, 16)) +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) + +interface I103 { next: I104 } +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) +>next : Symbol(I103.next, Decl(relationDepthSharedCheckOrder.ts, 212, 16)) +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) + +interface J103 { next: J104 } +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) +>next : Symbol(J103.next, Decl(relationDepthSharedCheckOrder.ts, 213, 16)) +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) + +interface I104 { next: I105 } +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) +>next : Symbol(I104.next, Decl(relationDepthSharedCheckOrder.ts, 214, 16)) +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) + +interface J104 { next: J105 } +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) +>next : Symbol(J104.next, Decl(relationDepthSharedCheckOrder.ts, 215, 16)) +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) + +interface I105 { next: I106 } +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) +>next : Symbol(I105.next, Decl(relationDepthSharedCheckOrder.ts, 216, 16)) +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) + +interface J105 { next: J106 } +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) +>next : Symbol(J105.next, Decl(relationDepthSharedCheckOrder.ts, 217, 16)) +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) + +interface I106 { next: I107 } +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) +>next : Symbol(I106.next, Decl(relationDepthSharedCheckOrder.ts, 218, 16)) +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) + +interface J106 { next: J107 } +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) +>next : Symbol(J106.next, Decl(relationDepthSharedCheckOrder.ts, 219, 16)) +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) + +interface I107 { next: I108 } +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) +>next : Symbol(I107.next, Decl(relationDepthSharedCheckOrder.ts, 220, 16)) +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) + +interface J107 { next: J108 } +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) +>next : Symbol(J107.next, Decl(relationDepthSharedCheckOrder.ts, 221, 16)) +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) + +interface I108 { next: I109 } +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) +>next : Symbol(I108.next, Decl(relationDepthSharedCheckOrder.ts, 222, 16)) +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) + +interface J108 { next: J109 } +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) +>next : Symbol(J108.next, Decl(relationDepthSharedCheckOrder.ts, 223, 16)) +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) + +interface I109 { next: I110 } +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) +>next : Symbol(I109.next, Decl(relationDepthSharedCheckOrder.ts, 224, 16)) +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) + +interface J109 { next: J110 } +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) +>next : Symbol(J109.next, Decl(relationDepthSharedCheckOrder.ts, 225, 16)) +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) + +interface I110 { next: I111 } +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) +>next : Symbol(I110.next, Decl(relationDepthSharedCheckOrder.ts, 226, 16)) +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) + +interface J110 { next: J111 } +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) +>next : Symbol(J110.next, Decl(relationDepthSharedCheckOrder.ts, 227, 16)) +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) + +interface I111 { next: I112 } +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) +>next : Symbol(I111.next, Decl(relationDepthSharedCheckOrder.ts, 228, 16)) +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) + +interface J111 { next: J112 } +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) +>next : Symbol(J111.next, Decl(relationDepthSharedCheckOrder.ts, 229, 16)) +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) + +interface I112 { next: I113 } +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) +>next : Symbol(I112.next, Decl(relationDepthSharedCheckOrder.ts, 230, 16)) +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) + +interface J112 { next: J113 } +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) +>next : Symbol(J112.next, Decl(relationDepthSharedCheckOrder.ts, 231, 16)) +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) + +interface I113 { next: I114 } +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) +>next : Symbol(I113.next, Decl(relationDepthSharedCheckOrder.ts, 232, 16)) +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) + +interface J113 { next: J114 } +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) +>next : Symbol(J113.next, Decl(relationDepthSharedCheckOrder.ts, 233, 16)) +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) + +interface I114 { next: I115 } +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) +>next : Symbol(I114.next, Decl(relationDepthSharedCheckOrder.ts, 234, 16)) +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) + +interface J114 { next: J115 } +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) +>next : Symbol(J114.next, Decl(relationDepthSharedCheckOrder.ts, 235, 16)) +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) + +interface I115 { next: I116 } +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) +>next : Symbol(I115.next, Decl(relationDepthSharedCheckOrder.ts, 236, 16)) +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) + +interface J115 { next: J116 } +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) +>next : Symbol(J115.next, Decl(relationDepthSharedCheckOrder.ts, 237, 16)) +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) + +interface I116 { next: I117 } +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) +>next : Symbol(I116.next, Decl(relationDepthSharedCheckOrder.ts, 238, 16)) +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) + +interface J116 { next: J117 } +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) +>next : Symbol(J116.next, Decl(relationDepthSharedCheckOrder.ts, 239, 16)) +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) + +interface I117 { next: I118 } +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) +>next : Symbol(I117.next, Decl(relationDepthSharedCheckOrder.ts, 240, 16)) +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) + +interface J117 { next: J118 } +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) +>next : Symbol(J117.next, Decl(relationDepthSharedCheckOrder.ts, 241, 16)) +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) + +interface I118 { next: I119 } +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) +>next : Symbol(I118.next, Decl(relationDepthSharedCheckOrder.ts, 242, 16)) +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) + +interface J118 { next: J119 } +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) +>next : Symbol(J118.next, Decl(relationDepthSharedCheckOrder.ts, 243, 16)) +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) + +interface I119 { leaf: string } +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) +>leaf : Symbol(I119.leaf, Decl(relationDepthSharedCheckOrder.ts, 244, 16)) + +interface J119 { leaf: number } +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) +>leaf : Symbol(J119.leaf, Decl(relationDepthSharedCheckOrder.ts, 245, 16)) + +type Mid = I60 extends J60 ? true : false; +>Mid : Symbol(Mid, Decl(relationDepthSharedCheckOrder.ts, 245, 31)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +type All = I0 extends J0 ? true : false; +>All : Symbol(All, Decl(relationDepthSharedCheckOrder.ts, 247, 42)) +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..e24834758fb2e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).types @@ -0,0 +1,739 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>next : I1 + +interface J0 { next: J1 } +>next : J1 + +interface I1 { next: I2 } +>next : I2 + +interface J1 { next: J2 } +>next : J2 + +interface I2 { next: I3 } +>next : I3 + +interface J2 { next: J3 } +>next : J3 + +interface I3 { next: I4 } +>next : I4 + +interface J3 { next: J4 } +>next : J4 + +interface I4 { next: I5 } +>next : I5 + +interface J4 { next: J5 } +>next : J5 + +interface I5 { next: I6 } +>next : I6 + +interface J5 { next: J6 } +>next : J6 + +interface I6 { next: I7 } +>next : I7 + +interface J6 { next: J7 } +>next : J7 + +interface I7 { next: I8 } +>next : I8 + +interface J7 { next: J8 } +>next : J8 + +interface I8 { next: I9 } +>next : I9 + +interface J8 { next: J9 } +>next : J9 + +interface I9 { next: I10 } +>next : I10 + +interface J9 { next: J10 } +>next : J10 + +interface I10 { next: I11 } +>next : I11 + +interface J10 { next: J11 } +>next : J11 + +interface I11 { next: I12 } +>next : I12 + +interface J11 { next: J12 } +>next : J12 + +interface I12 { next: I13 } +>next : I13 + +interface J12 { next: J13 } +>next : J13 + +interface I13 { next: I14 } +>next : I14 + +interface J13 { next: J14 } +>next : J14 + +interface I14 { next: I15 } +>next : I15 + +interface J14 { next: J15 } +>next : J15 + +interface I15 { next: I16 } +>next : I16 + +interface J15 { next: J16 } +>next : J16 + +interface I16 { next: I17 } +>next : I17 + +interface J16 { next: J17 } +>next : J17 + +interface I17 { next: I18 } +>next : I18 + +interface J17 { next: J18 } +>next : J18 + +interface I18 { next: I19 } +>next : I19 + +interface J18 { next: J19 } +>next : J19 + +interface I19 { next: I20 } +>next : I20 + +interface J19 { next: J20 } +>next : J20 + +interface I20 { next: I21 } +>next : I21 + +interface J20 { next: J21 } +>next : J21 + +interface I21 { next: I22 } +>next : I22 + +interface J21 { next: J22 } +>next : J22 + +interface I22 { next: I23 } +>next : I23 + +interface J22 { next: J23 } +>next : J23 + +interface I23 { next: I24 } +>next : I24 + +interface J23 { next: J24 } +>next : J24 + +interface I24 { next: I25 } +>next : I25 + +interface J24 { next: J25 } +>next : J25 + +interface I25 { next: I26 } +>next : I26 + +interface J25 { next: J26 } +>next : J26 + +interface I26 { next: I27 } +>next : I27 + +interface J26 { next: J27 } +>next : J27 + +interface I27 { next: I28 } +>next : I28 + +interface J27 { next: J28 } +>next : J28 + +interface I28 { next: I29 } +>next : I29 + +interface J28 { next: J29 } +>next : J29 + +interface I29 { next: I30 } +>next : I30 + +interface J29 { next: J30 } +>next : J30 + +interface I30 { next: I31 } +>next : I31 + +interface J30 { next: J31 } +>next : J31 + +interface I31 { next: I32 } +>next : I32 + +interface J31 { next: J32 } +>next : J32 + +interface I32 { next: I33 } +>next : I33 + +interface J32 { next: J33 } +>next : J33 + +interface I33 { next: I34 } +>next : I34 + +interface J33 { next: J34 } +>next : J34 + +interface I34 { next: I35 } +>next : I35 + +interface J34 { next: J35 } +>next : J35 + +interface I35 { next: I36 } +>next : I36 + +interface J35 { next: J36 } +>next : J36 + +interface I36 { next: I37 } +>next : I37 + +interface J36 { next: J37 } +>next : J37 + +interface I37 { next: I38 } +>next : I38 + +interface J37 { next: J38 } +>next : J38 + +interface I38 { next: I39 } +>next : I39 + +interface J38 { next: J39 } +>next : J39 + +interface I39 { next: I40 } +>next : I40 + +interface J39 { next: J40 } +>next : J40 + +interface I40 { next: I41 } +>next : I41 + +interface J40 { next: J41 } +>next : J41 + +interface I41 { next: I42 } +>next : I42 + +interface J41 { next: J42 } +>next : J42 + +interface I42 { next: I43 } +>next : I43 + +interface J42 { next: J43 } +>next : J43 + +interface I43 { next: I44 } +>next : I44 + +interface J43 { next: J44 } +>next : J44 + +interface I44 { next: I45 } +>next : I45 + +interface J44 { next: J45 } +>next : J45 + +interface I45 { next: I46 } +>next : I46 + +interface J45 { next: J46 } +>next : J46 + +interface I46 { next: I47 } +>next : I47 + +interface J46 { next: J47 } +>next : J47 + +interface I47 { next: I48 } +>next : I48 + +interface J47 { next: J48 } +>next : J48 + +interface I48 { next: I49 } +>next : I49 + +interface J48 { next: J49 } +>next : J49 + +interface I49 { next: I50 } +>next : I50 + +interface J49 { next: J50 } +>next : J50 + +interface I50 { next: I51 } +>next : I51 + +interface J50 { next: J51 } +>next : J51 + +interface I51 { next: I52 } +>next : I52 + +interface J51 { next: J52 } +>next : J52 + +interface I52 { next: I53 } +>next : I53 + +interface J52 { next: J53 } +>next : J53 + +interface I53 { next: I54 } +>next : I54 + +interface J53 { next: J54 } +>next : J54 + +interface I54 { next: I55 } +>next : I55 + +interface J54 { next: J55 } +>next : J55 + +interface I55 { next: I56 } +>next : I56 + +interface J55 { next: J56 } +>next : J56 + +interface I56 { next: I57 } +>next : I57 + +interface J56 { next: J57 } +>next : J57 + +interface I57 { next: I58 } +>next : I58 + +interface J57 { next: J58 } +>next : J58 + +interface I58 { next: I59 } +>next : I59 + +interface J58 { next: J59 } +>next : J59 + +interface I59 { next: I60 } +>next : I60 + +interface J59 { next: J60 } +>next : J60 + +interface I60 { next: I61 } +>next : I61 + +interface J60 { next: J61 } +>next : J61 + +interface I61 { next: I62 } +>next : I62 + +interface J61 { next: J62 } +>next : J62 + +interface I62 { next: I63 } +>next : I63 + +interface J62 { next: J63 } +>next : J63 + +interface I63 { next: I64 } +>next : I64 + +interface J63 { next: J64 } +>next : J64 + +interface I64 { next: I65 } +>next : I65 + +interface J64 { next: J65 } +>next : J65 + +interface I65 { next: I66 } +>next : I66 + +interface J65 { next: J66 } +>next : J66 + +interface I66 { next: I67 } +>next : I67 + +interface J66 { next: J67 } +>next : J67 + +interface I67 { next: I68 } +>next : I68 + +interface J67 { next: J68 } +>next : J68 + +interface I68 { next: I69 } +>next : I69 + +interface J68 { next: J69 } +>next : J69 + +interface I69 { next: I70 } +>next : I70 + +interface J69 { next: J70 } +>next : J70 + +interface I70 { next: I71 } +>next : I71 + +interface J70 { next: J71 } +>next : J71 + +interface I71 { next: I72 } +>next : I72 + +interface J71 { next: J72 } +>next : J72 + +interface I72 { next: I73 } +>next : I73 + +interface J72 { next: J73 } +>next : J73 + +interface I73 { next: I74 } +>next : I74 + +interface J73 { next: J74 } +>next : J74 + +interface I74 { next: I75 } +>next : I75 + +interface J74 { next: J75 } +>next : J75 + +interface I75 { next: I76 } +>next : I76 + +interface J75 { next: J76 } +>next : J76 + +interface I76 { next: I77 } +>next : I77 + +interface J76 { next: J77 } +>next : J77 + +interface I77 { next: I78 } +>next : I78 + +interface J77 { next: J78 } +>next : J78 + +interface I78 { next: I79 } +>next : I79 + +interface J78 { next: J79 } +>next : J79 + +interface I79 { next: I80 } +>next : I80 + +interface J79 { next: J80 } +>next : J80 + +interface I80 { next: I81 } +>next : I81 + +interface J80 { next: J81 } +>next : J81 + +interface I81 { next: I82 } +>next : I82 + +interface J81 { next: J82 } +>next : J82 + +interface I82 { next: I83 } +>next : I83 + +interface J82 { next: J83 } +>next : J83 + +interface I83 { next: I84 } +>next : I84 + +interface J83 { next: J84 } +>next : J84 + +interface I84 { next: I85 } +>next : I85 + +interface J84 { next: J85 } +>next : J85 + +interface I85 { next: I86 } +>next : I86 + +interface J85 { next: J86 } +>next : J86 + +interface I86 { next: I87 } +>next : I87 + +interface J86 { next: J87 } +>next : J87 + +interface I87 { next: I88 } +>next : I88 + +interface J87 { next: J88 } +>next : J88 + +interface I88 { next: I89 } +>next : I89 + +interface J88 { next: J89 } +>next : J89 + +interface I89 { next: I90 } +>next : I90 + +interface J89 { next: J90 } +>next : J90 + +interface I90 { next: I91 } +>next : I91 + +interface J90 { next: J91 } +>next : J91 + +interface I91 { next: I92 } +>next : I92 + +interface J91 { next: J92 } +>next : J92 + +interface I92 { next: I93 } +>next : I93 + +interface J92 { next: J93 } +>next : J93 + +interface I93 { next: I94 } +>next : I94 + +interface J93 { next: J94 } +>next : J94 + +interface I94 { next: I95 } +>next : I95 + +interface J94 { next: J95 } +>next : J95 + +interface I95 { next: I96 } +>next : I96 + +interface J95 { next: J96 } +>next : J96 + +interface I96 { next: I97 } +>next : I97 + +interface J96 { next: J97 } +>next : J97 + +interface I97 { next: I98 } +>next : I98 + +interface J97 { next: J98 } +>next : J98 + +interface I98 { next: I99 } +>next : I99 + +interface J98 { next: J99 } +>next : J99 + +interface I99 { next: I100 } +>next : I100 + +interface J99 { next: J100 } +>next : J100 + +interface I100 { next: I101 } +>next : I101 + +interface J100 { next: J101 } +>next : J101 + +interface I101 { next: I102 } +>next : I102 + +interface J101 { next: J102 } +>next : J102 + +interface I102 { next: I103 } +>next : I103 + +interface J102 { next: J103 } +>next : J103 + +interface I103 { next: I104 } +>next : I104 + +interface J103 { next: J104 } +>next : J104 + +interface I104 { next: I105 } +>next : I105 + +interface J104 { next: J105 } +>next : J105 + +interface I105 { next: I106 } +>next : I106 + +interface J105 { next: J106 } +>next : J106 + +interface I106 { next: I107 } +>next : I107 + +interface J106 { next: J107 } +>next : J107 + +interface I107 { next: I108 } +>next : I108 + +interface J107 { next: J108 } +>next : J108 + +interface I108 { next: I109 } +>next : I109 + +interface J108 { next: J109 } +>next : J109 + +interface I109 { next: I110 } +>next : I110 + +interface J109 { next: J110 } +>next : J110 + +interface I110 { next: I111 } +>next : I111 + +interface J110 { next: J111 } +>next : J111 + +interface I111 { next: I112 } +>next : I112 + +interface J111 { next: J112 } +>next : J112 + +interface I112 { next: I113 } +>next : I113 + +interface J112 { next: J113 } +>next : J113 + +interface I113 { next: I114 } +>next : I114 + +interface J113 { next: J114 } +>next : J114 + +interface I114 { next: I115 } +>next : I115 + +interface J114 { next: J115 } +>next : J115 + +interface I115 { next: I116 } +>next : I116 + +interface J115 { next: J116 } +>next : J116 + +interface I116 { next: I117 } +>next : I117 + +interface J116 { next: J117 } +>next : J117 + +interface I117 { next: I118 } +>next : I118 + +interface J117 { next: J118 } +>next : J118 + +interface I118 { next: I119 } +>next : I119 + +interface J118 { next: J119 } +>next : J119 + +interface I119 { leaf: string } +>leaf : string + +interface J119 { leaf: number } +>leaf : number + +type Mid = I60 extends J60 ? true : false; +>Mid : false +>true : true +>false : false + +type All = I0 extends J0 ? true : false; +>All : false +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..89aebb5fd9f9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,1217 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>next : Symbol(I0.next, Decl(relationDepthSharedCheckOrder.ts, 6, 14)) +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) + +interface J0 { next: J1 } +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) +>next : Symbol(J0.next, Decl(relationDepthSharedCheckOrder.ts, 7, 14)) +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) + +interface I1 { next: I2 } +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) +>next : Symbol(I1.next, Decl(relationDepthSharedCheckOrder.ts, 8, 14)) +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) + +interface J1 { next: J2 } +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) +>next : Symbol(J1.next, Decl(relationDepthSharedCheckOrder.ts, 9, 14)) +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) + +interface I2 { next: I3 } +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) +>next : Symbol(I2.next, Decl(relationDepthSharedCheckOrder.ts, 10, 14)) +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) + +interface J2 { next: J3 } +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) +>next : Symbol(J2.next, Decl(relationDepthSharedCheckOrder.ts, 11, 14)) +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) + +interface I3 { next: I4 } +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) +>next : Symbol(I3.next, Decl(relationDepthSharedCheckOrder.ts, 12, 14)) +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) + +interface J3 { next: J4 } +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) +>next : Symbol(J3.next, Decl(relationDepthSharedCheckOrder.ts, 13, 14)) +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) + +interface I4 { next: I5 } +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) +>next : Symbol(I4.next, Decl(relationDepthSharedCheckOrder.ts, 14, 14)) +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) + +interface J4 { next: J5 } +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) +>next : Symbol(J4.next, Decl(relationDepthSharedCheckOrder.ts, 15, 14)) +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) + +interface I5 { next: I6 } +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) +>next : Symbol(I5.next, Decl(relationDepthSharedCheckOrder.ts, 16, 14)) +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) + +interface J5 { next: J6 } +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) +>next : Symbol(J5.next, Decl(relationDepthSharedCheckOrder.ts, 17, 14)) +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) + +interface I6 { next: I7 } +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) +>next : Symbol(I6.next, Decl(relationDepthSharedCheckOrder.ts, 18, 14)) +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) + +interface J6 { next: J7 } +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) +>next : Symbol(J6.next, Decl(relationDepthSharedCheckOrder.ts, 19, 14)) +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) + +interface I7 { next: I8 } +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) +>next : Symbol(I7.next, Decl(relationDepthSharedCheckOrder.ts, 20, 14)) +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) + +interface J7 { next: J8 } +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) +>next : Symbol(J7.next, Decl(relationDepthSharedCheckOrder.ts, 21, 14)) +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) + +interface I8 { next: I9 } +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) +>next : Symbol(I8.next, Decl(relationDepthSharedCheckOrder.ts, 22, 14)) +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) + +interface J8 { next: J9 } +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) +>next : Symbol(J8.next, Decl(relationDepthSharedCheckOrder.ts, 23, 14)) +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) + +interface I9 { next: I10 } +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) +>next : Symbol(I9.next, Decl(relationDepthSharedCheckOrder.ts, 24, 14)) +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) + +interface J9 { next: J10 } +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) +>next : Symbol(J9.next, Decl(relationDepthSharedCheckOrder.ts, 25, 14)) +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) + +interface I10 { next: I11 } +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) +>next : Symbol(I10.next, Decl(relationDepthSharedCheckOrder.ts, 26, 15)) +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) + +interface J10 { next: J11 } +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) +>next : Symbol(J10.next, Decl(relationDepthSharedCheckOrder.ts, 27, 15)) +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) + +interface I11 { next: I12 } +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) +>next : Symbol(I11.next, Decl(relationDepthSharedCheckOrder.ts, 28, 15)) +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) + +interface J11 { next: J12 } +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) +>next : Symbol(J11.next, Decl(relationDepthSharedCheckOrder.ts, 29, 15)) +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) + +interface I12 { next: I13 } +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) +>next : Symbol(I12.next, Decl(relationDepthSharedCheckOrder.ts, 30, 15)) +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) + +interface J12 { next: J13 } +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) +>next : Symbol(J12.next, Decl(relationDepthSharedCheckOrder.ts, 31, 15)) +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) + +interface I13 { next: I14 } +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) +>next : Symbol(I13.next, Decl(relationDepthSharedCheckOrder.ts, 32, 15)) +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) + +interface J13 { next: J14 } +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) +>next : Symbol(J13.next, Decl(relationDepthSharedCheckOrder.ts, 33, 15)) +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) + +interface I14 { next: I15 } +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) +>next : Symbol(I14.next, Decl(relationDepthSharedCheckOrder.ts, 34, 15)) +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) + +interface J14 { next: J15 } +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) +>next : Symbol(J14.next, Decl(relationDepthSharedCheckOrder.ts, 35, 15)) +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) + +interface I15 { next: I16 } +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) +>next : Symbol(I15.next, Decl(relationDepthSharedCheckOrder.ts, 36, 15)) +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) + +interface J15 { next: J16 } +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) +>next : Symbol(J15.next, Decl(relationDepthSharedCheckOrder.ts, 37, 15)) +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) + +interface I16 { next: I17 } +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) +>next : Symbol(I16.next, Decl(relationDepthSharedCheckOrder.ts, 38, 15)) +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) + +interface J16 { next: J17 } +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) +>next : Symbol(J16.next, Decl(relationDepthSharedCheckOrder.ts, 39, 15)) +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) + +interface I17 { next: I18 } +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) +>next : Symbol(I17.next, Decl(relationDepthSharedCheckOrder.ts, 40, 15)) +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) + +interface J17 { next: J18 } +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) +>next : Symbol(J17.next, Decl(relationDepthSharedCheckOrder.ts, 41, 15)) +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) + +interface I18 { next: I19 } +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) +>next : Symbol(I18.next, Decl(relationDepthSharedCheckOrder.ts, 42, 15)) +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) + +interface J18 { next: J19 } +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) +>next : Symbol(J18.next, Decl(relationDepthSharedCheckOrder.ts, 43, 15)) +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) + +interface I19 { next: I20 } +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) +>next : Symbol(I19.next, Decl(relationDepthSharedCheckOrder.ts, 44, 15)) +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) + +interface J19 { next: J20 } +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) +>next : Symbol(J19.next, Decl(relationDepthSharedCheckOrder.ts, 45, 15)) +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) + +interface I20 { next: I21 } +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) +>next : Symbol(I20.next, Decl(relationDepthSharedCheckOrder.ts, 46, 15)) +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) + +interface J20 { next: J21 } +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) +>next : Symbol(J20.next, Decl(relationDepthSharedCheckOrder.ts, 47, 15)) +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) + +interface I21 { next: I22 } +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) +>next : Symbol(I21.next, Decl(relationDepthSharedCheckOrder.ts, 48, 15)) +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) + +interface J21 { next: J22 } +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) +>next : Symbol(J21.next, Decl(relationDepthSharedCheckOrder.ts, 49, 15)) +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) + +interface I22 { next: I23 } +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) +>next : Symbol(I22.next, Decl(relationDepthSharedCheckOrder.ts, 50, 15)) +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) + +interface J22 { next: J23 } +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) +>next : Symbol(J22.next, Decl(relationDepthSharedCheckOrder.ts, 51, 15)) +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) + +interface I23 { next: I24 } +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) +>next : Symbol(I23.next, Decl(relationDepthSharedCheckOrder.ts, 52, 15)) +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) + +interface J23 { next: J24 } +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) +>next : Symbol(J23.next, Decl(relationDepthSharedCheckOrder.ts, 53, 15)) +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) + +interface I24 { next: I25 } +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) +>next : Symbol(I24.next, Decl(relationDepthSharedCheckOrder.ts, 54, 15)) +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) + +interface J24 { next: J25 } +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) +>next : Symbol(J24.next, Decl(relationDepthSharedCheckOrder.ts, 55, 15)) +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) + +interface I25 { next: I26 } +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) +>next : Symbol(I25.next, Decl(relationDepthSharedCheckOrder.ts, 56, 15)) +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) + +interface J25 { next: J26 } +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) +>next : Symbol(J25.next, Decl(relationDepthSharedCheckOrder.ts, 57, 15)) +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) + +interface I26 { next: I27 } +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) +>next : Symbol(I26.next, Decl(relationDepthSharedCheckOrder.ts, 58, 15)) +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) + +interface J26 { next: J27 } +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) +>next : Symbol(J26.next, Decl(relationDepthSharedCheckOrder.ts, 59, 15)) +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) + +interface I27 { next: I28 } +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) +>next : Symbol(I27.next, Decl(relationDepthSharedCheckOrder.ts, 60, 15)) +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) + +interface J27 { next: J28 } +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) +>next : Symbol(J27.next, Decl(relationDepthSharedCheckOrder.ts, 61, 15)) +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) + +interface I28 { next: I29 } +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) +>next : Symbol(I28.next, Decl(relationDepthSharedCheckOrder.ts, 62, 15)) +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) + +interface J28 { next: J29 } +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) +>next : Symbol(J28.next, Decl(relationDepthSharedCheckOrder.ts, 63, 15)) +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) + +interface I29 { next: I30 } +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) +>next : Symbol(I29.next, Decl(relationDepthSharedCheckOrder.ts, 64, 15)) +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) + +interface J29 { next: J30 } +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) +>next : Symbol(J29.next, Decl(relationDepthSharedCheckOrder.ts, 65, 15)) +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) + +interface I30 { next: I31 } +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) +>next : Symbol(I30.next, Decl(relationDepthSharedCheckOrder.ts, 66, 15)) +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) + +interface J30 { next: J31 } +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) +>next : Symbol(J30.next, Decl(relationDepthSharedCheckOrder.ts, 67, 15)) +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) + +interface I31 { next: I32 } +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) +>next : Symbol(I31.next, Decl(relationDepthSharedCheckOrder.ts, 68, 15)) +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) + +interface J31 { next: J32 } +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) +>next : Symbol(J31.next, Decl(relationDepthSharedCheckOrder.ts, 69, 15)) +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) + +interface I32 { next: I33 } +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) +>next : Symbol(I32.next, Decl(relationDepthSharedCheckOrder.ts, 70, 15)) +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) + +interface J32 { next: J33 } +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) +>next : Symbol(J32.next, Decl(relationDepthSharedCheckOrder.ts, 71, 15)) +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) + +interface I33 { next: I34 } +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) +>next : Symbol(I33.next, Decl(relationDepthSharedCheckOrder.ts, 72, 15)) +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) + +interface J33 { next: J34 } +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) +>next : Symbol(J33.next, Decl(relationDepthSharedCheckOrder.ts, 73, 15)) +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) + +interface I34 { next: I35 } +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) +>next : Symbol(I34.next, Decl(relationDepthSharedCheckOrder.ts, 74, 15)) +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) + +interface J34 { next: J35 } +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) +>next : Symbol(J34.next, Decl(relationDepthSharedCheckOrder.ts, 75, 15)) +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) + +interface I35 { next: I36 } +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) +>next : Symbol(I35.next, Decl(relationDepthSharedCheckOrder.ts, 76, 15)) +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) + +interface J35 { next: J36 } +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) +>next : Symbol(J35.next, Decl(relationDepthSharedCheckOrder.ts, 77, 15)) +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) + +interface I36 { next: I37 } +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) +>next : Symbol(I36.next, Decl(relationDepthSharedCheckOrder.ts, 78, 15)) +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) + +interface J36 { next: J37 } +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) +>next : Symbol(J36.next, Decl(relationDepthSharedCheckOrder.ts, 79, 15)) +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) + +interface I37 { next: I38 } +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) +>next : Symbol(I37.next, Decl(relationDepthSharedCheckOrder.ts, 80, 15)) +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) + +interface J37 { next: J38 } +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) +>next : Symbol(J37.next, Decl(relationDepthSharedCheckOrder.ts, 81, 15)) +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) + +interface I38 { next: I39 } +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) +>next : Symbol(I38.next, Decl(relationDepthSharedCheckOrder.ts, 82, 15)) +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) + +interface J38 { next: J39 } +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) +>next : Symbol(J38.next, Decl(relationDepthSharedCheckOrder.ts, 83, 15)) +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) + +interface I39 { next: I40 } +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) +>next : Symbol(I39.next, Decl(relationDepthSharedCheckOrder.ts, 84, 15)) +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) + +interface J39 { next: J40 } +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) +>next : Symbol(J39.next, Decl(relationDepthSharedCheckOrder.ts, 85, 15)) +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) + +interface I40 { next: I41 } +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) +>next : Symbol(I40.next, Decl(relationDepthSharedCheckOrder.ts, 86, 15)) +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) + +interface J40 { next: J41 } +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) +>next : Symbol(J40.next, Decl(relationDepthSharedCheckOrder.ts, 87, 15)) +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) + +interface I41 { next: I42 } +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) +>next : Symbol(I41.next, Decl(relationDepthSharedCheckOrder.ts, 88, 15)) +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) + +interface J41 { next: J42 } +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) +>next : Symbol(J41.next, Decl(relationDepthSharedCheckOrder.ts, 89, 15)) +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) + +interface I42 { next: I43 } +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) +>next : Symbol(I42.next, Decl(relationDepthSharedCheckOrder.ts, 90, 15)) +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) + +interface J42 { next: J43 } +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) +>next : Symbol(J42.next, Decl(relationDepthSharedCheckOrder.ts, 91, 15)) +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) + +interface I43 { next: I44 } +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) +>next : Symbol(I43.next, Decl(relationDepthSharedCheckOrder.ts, 92, 15)) +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) + +interface J43 { next: J44 } +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) +>next : Symbol(J43.next, Decl(relationDepthSharedCheckOrder.ts, 93, 15)) +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) + +interface I44 { next: I45 } +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) +>next : Symbol(I44.next, Decl(relationDepthSharedCheckOrder.ts, 94, 15)) +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) + +interface J44 { next: J45 } +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) +>next : Symbol(J44.next, Decl(relationDepthSharedCheckOrder.ts, 95, 15)) +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) + +interface I45 { next: I46 } +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) +>next : Symbol(I45.next, Decl(relationDepthSharedCheckOrder.ts, 96, 15)) +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) + +interface J45 { next: J46 } +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) +>next : Symbol(J45.next, Decl(relationDepthSharedCheckOrder.ts, 97, 15)) +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) + +interface I46 { next: I47 } +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) +>next : Symbol(I46.next, Decl(relationDepthSharedCheckOrder.ts, 98, 15)) +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) + +interface J46 { next: J47 } +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) +>next : Symbol(J46.next, Decl(relationDepthSharedCheckOrder.ts, 99, 15)) +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) + +interface I47 { next: I48 } +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) +>next : Symbol(I47.next, Decl(relationDepthSharedCheckOrder.ts, 100, 15)) +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) + +interface J47 { next: J48 } +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) +>next : Symbol(J47.next, Decl(relationDepthSharedCheckOrder.ts, 101, 15)) +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) + +interface I48 { next: I49 } +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) +>next : Symbol(I48.next, Decl(relationDepthSharedCheckOrder.ts, 102, 15)) +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) + +interface J48 { next: J49 } +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) +>next : Symbol(J48.next, Decl(relationDepthSharedCheckOrder.ts, 103, 15)) +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) + +interface I49 { next: I50 } +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) +>next : Symbol(I49.next, Decl(relationDepthSharedCheckOrder.ts, 104, 15)) +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) + +interface J49 { next: J50 } +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) +>next : Symbol(J49.next, Decl(relationDepthSharedCheckOrder.ts, 105, 15)) +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) + +interface I50 { next: I51 } +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) +>next : Symbol(I50.next, Decl(relationDepthSharedCheckOrder.ts, 106, 15)) +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) + +interface J50 { next: J51 } +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) +>next : Symbol(J50.next, Decl(relationDepthSharedCheckOrder.ts, 107, 15)) +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) + +interface I51 { next: I52 } +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) +>next : Symbol(I51.next, Decl(relationDepthSharedCheckOrder.ts, 108, 15)) +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) + +interface J51 { next: J52 } +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) +>next : Symbol(J51.next, Decl(relationDepthSharedCheckOrder.ts, 109, 15)) +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) + +interface I52 { next: I53 } +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) +>next : Symbol(I52.next, Decl(relationDepthSharedCheckOrder.ts, 110, 15)) +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) + +interface J52 { next: J53 } +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) +>next : Symbol(J52.next, Decl(relationDepthSharedCheckOrder.ts, 111, 15)) +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) + +interface I53 { next: I54 } +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) +>next : Symbol(I53.next, Decl(relationDepthSharedCheckOrder.ts, 112, 15)) +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) + +interface J53 { next: J54 } +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) +>next : Symbol(J53.next, Decl(relationDepthSharedCheckOrder.ts, 113, 15)) +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) + +interface I54 { next: I55 } +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) +>next : Symbol(I54.next, Decl(relationDepthSharedCheckOrder.ts, 114, 15)) +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) + +interface J54 { next: J55 } +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) +>next : Symbol(J54.next, Decl(relationDepthSharedCheckOrder.ts, 115, 15)) +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) + +interface I55 { next: I56 } +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) +>next : Symbol(I55.next, Decl(relationDepthSharedCheckOrder.ts, 116, 15)) +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) + +interface J55 { next: J56 } +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) +>next : Symbol(J55.next, Decl(relationDepthSharedCheckOrder.ts, 117, 15)) +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) + +interface I56 { next: I57 } +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) +>next : Symbol(I56.next, Decl(relationDepthSharedCheckOrder.ts, 118, 15)) +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) + +interface J56 { next: J57 } +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) +>next : Symbol(J56.next, Decl(relationDepthSharedCheckOrder.ts, 119, 15)) +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) + +interface I57 { next: I58 } +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) +>next : Symbol(I57.next, Decl(relationDepthSharedCheckOrder.ts, 120, 15)) +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) + +interface J57 { next: J58 } +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) +>next : Symbol(J57.next, Decl(relationDepthSharedCheckOrder.ts, 121, 15)) +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) + +interface I58 { next: I59 } +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) +>next : Symbol(I58.next, Decl(relationDepthSharedCheckOrder.ts, 122, 15)) +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) + +interface J58 { next: J59 } +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) +>next : Symbol(J58.next, Decl(relationDepthSharedCheckOrder.ts, 123, 15)) +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) + +interface I59 { next: I60 } +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) +>next : Symbol(I59.next, Decl(relationDepthSharedCheckOrder.ts, 124, 15)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) + +interface J59 { next: J60 } +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) +>next : Symbol(J59.next, Decl(relationDepthSharedCheckOrder.ts, 125, 15)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +interface I60 { next: I61 } +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>next : Symbol(I60.next, Decl(relationDepthSharedCheckOrder.ts, 126, 15)) +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) + +interface J60 { next: J61 } +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) +>next : Symbol(J60.next, Decl(relationDepthSharedCheckOrder.ts, 127, 15)) +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) + +interface I61 { next: I62 } +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) +>next : Symbol(I61.next, Decl(relationDepthSharedCheckOrder.ts, 128, 15)) +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) + +interface J61 { next: J62 } +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) +>next : Symbol(J61.next, Decl(relationDepthSharedCheckOrder.ts, 129, 15)) +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) + +interface I62 { next: I63 } +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) +>next : Symbol(I62.next, Decl(relationDepthSharedCheckOrder.ts, 130, 15)) +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) + +interface J62 { next: J63 } +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) +>next : Symbol(J62.next, Decl(relationDepthSharedCheckOrder.ts, 131, 15)) +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) + +interface I63 { next: I64 } +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) +>next : Symbol(I63.next, Decl(relationDepthSharedCheckOrder.ts, 132, 15)) +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) + +interface J63 { next: J64 } +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) +>next : Symbol(J63.next, Decl(relationDepthSharedCheckOrder.ts, 133, 15)) +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) + +interface I64 { next: I65 } +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) +>next : Symbol(I64.next, Decl(relationDepthSharedCheckOrder.ts, 134, 15)) +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) + +interface J64 { next: J65 } +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) +>next : Symbol(J64.next, Decl(relationDepthSharedCheckOrder.ts, 135, 15)) +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) + +interface I65 { next: I66 } +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) +>next : Symbol(I65.next, Decl(relationDepthSharedCheckOrder.ts, 136, 15)) +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) + +interface J65 { next: J66 } +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) +>next : Symbol(J65.next, Decl(relationDepthSharedCheckOrder.ts, 137, 15)) +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) + +interface I66 { next: I67 } +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) +>next : Symbol(I66.next, Decl(relationDepthSharedCheckOrder.ts, 138, 15)) +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) + +interface J66 { next: J67 } +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) +>next : Symbol(J66.next, Decl(relationDepthSharedCheckOrder.ts, 139, 15)) +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) + +interface I67 { next: I68 } +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) +>next : Symbol(I67.next, Decl(relationDepthSharedCheckOrder.ts, 140, 15)) +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) + +interface J67 { next: J68 } +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) +>next : Symbol(J67.next, Decl(relationDepthSharedCheckOrder.ts, 141, 15)) +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) + +interface I68 { next: I69 } +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) +>next : Symbol(I68.next, Decl(relationDepthSharedCheckOrder.ts, 142, 15)) +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) + +interface J68 { next: J69 } +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) +>next : Symbol(J68.next, Decl(relationDepthSharedCheckOrder.ts, 143, 15)) +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) + +interface I69 { next: I70 } +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) +>next : Symbol(I69.next, Decl(relationDepthSharedCheckOrder.ts, 144, 15)) +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) + +interface J69 { next: J70 } +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) +>next : Symbol(J69.next, Decl(relationDepthSharedCheckOrder.ts, 145, 15)) +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) + +interface I70 { next: I71 } +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) +>next : Symbol(I70.next, Decl(relationDepthSharedCheckOrder.ts, 146, 15)) +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) + +interface J70 { next: J71 } +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) +>next : Symbol(J70.next, Decl(relationDepthSharedCheckOrder.ts, 147, 15)) +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) + +interface I71 { next: I72 } +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) +>next : Symbol(I71.next, Decl(relationDepthSharedCheckOrder.ts, 148, 15)) +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) + +interface J71 { next: J72 } +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) +>next : Symbol(J71.next, Decl(relationDepthSharedCheckOrder.ts, 149, 15)) +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) + +interface I72 { next: I73 } +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) +>next : Symbol(I72.next, Decl(relationDepthSharedCheckOrder.ts, 150, 15)) +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) + +interface J72 { next: J73 } +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) +>next : Symbol(J72.next, Decl(relationDepthSharedCheckOrder.ts, 151, 15)) +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) + +interface I73 { next: I74 } +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) +>next : Symbol(I73.next, Decl(relationDepthSharedCheckOrder.ts, 152, 15)) +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) + +interface J73 { next: J74 } +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) +>next : Symbol(J73.next, Decl(relationDepthSharedCheckOrder.ts, 153, 15)) +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) + +interface I74 { next: I75 } +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) +>next : Symbol(I74.next, Decl(relationDepthSharedCheckOrder.ts, 154, 15)) +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) + +interface J74 { next: J75 } +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) +>next : Symbol(J74.next, Decl(relationDepthSharedCheckOrder.ts, 155, 15)) +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) + +interface I75 { next: I76 } +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) +>next : Symbol(I75.next, Decl(relationDepthSharedCheckOrder.ts, 156, 15)) +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) + +interface J75 { next: J76 } +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) +>next : Symbol(J75.next, Decl(relationDepthSharedCheckOrder.ts, 157, 15)) +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) + +interface I76 { next: I77 } +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) +>next : Symbol(I76.next, Decl(relationDepthSharedCheckOrder.ts, 158, 15)) +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) + +interface J76 { next: J77 } +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) +>next : Symbol(J76.next, Decl(relationDepthSharedCheckOrder.ts, 159, 15)) +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) + +interface I77 { next: I78 } +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) +>next : Symbol(I77.next, Decl(relationDepthSharedCheckOrder.ts, 160, 15)) +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) + +interface J77 { next: J78 } +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) +>next : Symbol(J77.next, Decl(relationDepthSharedCheckOrder.ts, 161, 15)) +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) + +interface I78 { next: I79 } +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) +>next : Symbol(I78.next, Decl(relationDepthSharedCheckOrder.ts, 162, 15)) +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) + +interface J78 { next: J79 } +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) +>next : Symbol(J78.next, Decl(relationDepthSharedCheckOrder.ts, 163, 15)) +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) + +interface I79 { next: I80 } +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) +>next : Symbol(I79.next, Decl(relationDepthSharedCheckOrder.ts, 164, 15)) +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) + +interface J79 { next: J80 } +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) +>next : Symbol(J79.next, Decl(relationDepthSharedCheckOrder.ts, 165, 15)) +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) + +interface I80 { next: I81 } +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) +>next : Symbol(I80.next, Decl(relationDepthSharedCheckOrder.ts, 166, 15)) +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) + +interface J80 { next: J81 } +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) +>next : Symbol(J80.next, Decl(relationDepthSharedCheckOrder.ts, 167, 15)) +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) + +interface I81 { next: I82 } +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) +>next : Symbol(I81.next, Decl(relationDepthSharedCheckOrder.ts, 168, 15)) +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) + +interface J81 { next: J82 } +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) +>next : Symbol(J81.next, Decl(relationDepthSharedCheckOrder.ts, 169, 15)) +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) + +interface I82 { next: I83 } +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) +>next : Symbol(I82.next, Decl(relationDepthSharedCheckOrder.ts, 170, 15)) +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) + +interface J82 { next: J83 } +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) +>next : Symbol(J82.next, Decl(relationDepthSharedCheckOrder.ts, 171, 15)) +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) + +interface I83 { next: I84 } +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) +>next : Symbol(I83.next, Decl(relationDepthSharedCheckOrder.ts, 172, 15)) +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) + +interface J83 { next: J84 } +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) +>next : Symbol(J83.next, Decl(relationDepthSharedCheckOrder.ts, 173, 15)) +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) + +interface I84 { next: I85 } +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) +>next : Symbol(I84.next, Decl(relationDepthSharedCheckOrder.ts, 174, 15)) +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) + +interface J84 { next: J85 } +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) +>next : Symbol(J84.next, Decl(relationDepthSharedCheckOrder.ts, 175, 15)) +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) + +interface I85 { next: I86 } +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) +>next : Symbol(I85.next, Decl(relationDepthSharedCheckOrder.ts, 176, 15)) +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) + +interface J85 { next: J86 } +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) +>next : Symbol(J85.next, Decl(relationDepthSharedCheckOrder.ts, 177, 15)) +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) + +interface I86 { next: I87 } +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) +>next : Symbol(I86.next, Decl(relationDepthSharedCheckOrder.ts, 178, 15)) +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) + +interface J86 { next: J87 } +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) +>next : Symbol(J86.next, Decl(relationDepthSharedCheckOrder.ts, 179, 15)) +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) + +interface I87 { next: I88 } +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) +>next : Symbol(I87.next, Decl(relationDepthSharedCheckOrder.ts, 180, 15)) +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) + +interface J87 { next: J88 } +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) +>next : Symbol(J87.next, Decl(relationDepthSharedCheckOrder.ts, 181, 15)) +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) + +interface I88 { next: I89 } +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) +>next : Symbol(I88.next, Decl(relationDepthSharedCheckOrder.ts, 182, 15)) +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) + +interface J88 { next: J89 } +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) +>next : Symbol(J88.next, Decl(relationDepthSharedCheckOrder.ts, 183, 15)) +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) + +interface I89 { next: I90 } +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) +>next : Symbol(I89.next, Decl(relationDepthSharedCheckOrder.ts, 184, 15)) +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) + +interface J89 { next: J90 } +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) +>next : Symbol(J89.next, Decl(relationDepthSharedCheckOrder.ts, 185, 15)) +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) + +interface I90 { next: I91 } +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) +>next : Symbol(I90.next, Decl(relationDepthSharedCheckOrder.ts, 186, 15)) +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) + +interface J90 { next: J91 } +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) +>next : Symbol(J90.next, Decl(relationDepthSharedCheckOrder.ts, 187, 15)) +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) + +interface I91 { next: I92 } +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) +>next : Symbol(I91.next, Decl(relationDepthSharedCheckOrder.ts, 188, 15)) +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) + +interface J91 { next: J92 } +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) +>next : Symbol(J91.next, Decl(relationDepthSharedCheckOrder.ts, 189, 15)) +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) + +interface I92 { next: I93 } +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) +>next : Symbol(I92.next, Decl(relationDepthSharedCheckOrder.ts, 190, 15)) +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) + +interface J92 { next: J93 } +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) +>next : Symbol(J92.next, Decl(relationDepthSharedCheckOrder.ts, 191, 15)) +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) + +interface I93 { next: I94 } +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) +>next : Symbol(I93.next, Decl(relationDepthSharedCheckOrder.ts, 192, 15)) +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) + +interface J93 { next: J94 } +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) +>next : Symbol(J93.next, Decl(relationDepthSharedCheckOrder.ts, 193, 15)) +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) + +interface I94 { next: I95 } +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) +>next : Symbol(I94.next, Decl(relationDepthSharedCheckOrder.ts, 194, 15)) +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) + +interface J94 { next: J95 } +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) +>next : Symbol(J94.next, Decl(relationDepthSharedCheckOrder.ts, 195, 15)) +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) + +interface I95 { next: I96 } +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) +>next : Symbol(I95.next, Decl(relationDepthSharedCheckOrder.ts, 196, 15)) +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) + +interface J95 { next: J96 } +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) +>next : Symbol(J95.next, Decl(relationDepthSharedCheckOrder.ts, 197, 15)) +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) + +interface I96 { next: I97 } +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) +>next : Symbol(I96.next, Decl(relationDepthSharedCheckOrder.ts, 198, 15)) +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) + +interface J96 { next: J97 } +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) +>next : Symbol(J96.next, Decl(relationDepthSharedCheckOrder.ts, 199, 15)) +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) + +interface I97 { next: I98 } +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) +>next : Symbol(I97.next, Decl(relationDepthSharedCheckOrder.ts, 200, 15)) +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) + +interface J97 { next: J98 } +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) +>next : Symbol(J97.next, Decl(relationDepthSharedCheckOrder.ts, 201, 15)) +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) + +interface I98 { next: I99 } +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) +>next : Symbol(I98.next, Decl(relationDepthSharedCheckOrder.ts, 202, 15)) +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) + +interface J98 { next: J99 } +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) +>next : Symbol(J98.next, Decl(relationDepthSharedCheckOrder.ts, 203, 15)) +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) + +interface I99 { next: I100 } +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) +>next : Symbol(I99.next, Decl(relationDepthSharedCheckOrder.ts, 204, 15)) +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) + +interface J99 { next: J100 } +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) +>next : Symbol(J99.next, Decl(relationDepthSharedCheckOrder.ts, 205, 15)) +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) + +interface I100 { next: I101 } +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) +>next : Symbol(I100.next, Decl(relationDepthSharedCheckOrder.ts, 206, 16)) +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) + +interface J100 { next: J101 } +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) +>next : Symbol(J100.next, Decl(relationDepthSharedCheckOrder.ts, 207, 16)) +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) + +interface I101 { next: I102 } +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) +>next : Symbol(I101.next, Decl(relationDepthSharedCheckOrder.ts, 208, 16)) +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) + +interface J101 { next: J102 } +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) +>next : Symbol(J101.next, Decl(relationDepthSharedCheckOrder.ts, 209, 16)) +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) + +interface I102 { next: I103 } +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) +>next : Symbol(I102.next, Decl(relationDepthSharedCheckOrder.ts, 210, 16)) +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) + +interface J102 { next: J103 } +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) +>next : Symbol(J102.next, Decl(relationDepthSharedCheckOrder.ts, 211, 16)) +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) + +interface I103 { next: I104 } +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) +>next : Symbol(I103.next, Decl(relationDepthSharedCheckOrder.ts, 212, 16)) +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) + +interface J103 { next: J104 } +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) +>next : Symbol(J103.next, Decl(relationDepthSharedCheckOrder.ts, 213, 16)) +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) + +interface I104 { next: I105 } +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) +>next : Symbol(I104.next, Decl(relationDepthSharedCheckOrder.ts, 214, 16)) +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) + +interface J104 { next: J105 } +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) +>next : Symbol(J104.next, Decl(relationDepthSharedCheckOrder.ts, 215, 16)) +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) + +interface I105 { next: I106 } +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) +>next : Symbol(I105.next, Decl(relationDepthSharedCheckOrder.ts, 216, 16)) +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) + +interface J105 { next: J106 } +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) +>next : Symbol(J105.next, Decl(relationDepthSharedCheckOrder.ts, 217, 16)) +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) + +interface I106 { next: I107 } +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) +>next : Symbol(I106.next, Decl(relationDepthSharedCheckOrder.ts, 218, 16)) +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) + +interface J106 { next: J107 } +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) +>next : Symbol(J106.next, Decl(relationDepthSharedCheckOrder.ts, 219, 16)) +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) + +interface I107 { next: I108 } +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) +>next : Symbol(I107.next, Decl(relationDepthSharedCheckOrder.ts, 220, 16)) +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) + +interface J107 { next: J108 } +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) +>next : Symbol(J107.next, Decl(relationDepthSharedCheckOrder.ts, 221, 16)) +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) + +interface I108 { next: I109 } +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) +>next : Symbol(I108.next, Decl(relationDepthSharedCheckOrder.ts, 222, 16)) +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) + +interface J108 { next: J109 } +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) +>next : Symbol(J108.next, Decl(relationDepthSharedCheckOrder.ts, 223, 16)) +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) + +interface I109 { next: I110 } +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) +>next : Symbol(I109.next, Decl(relationDepthSharedCheckOrder.ts, 224, 16)) +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) + +interface J109 { next: J110 } +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) +>next : Symbol(J109.next, Decl(relationDepthSharedCheckOrder.ts, 225, 16)) +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) + +interface I110 { next: I111 } +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) +>next : Symbol(I110.next, Decl(relationDepthSharedCheckOrder.ts, 226, 16)) +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) + +interface J110 { next: J111 } +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) +>next : Symbol(J110.next, Decl(relationDepthSharedCheckOrder.ts, 227, 16)) +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) + +interface I111 { next: I112 } +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) +>next : Symbol(I111.next, Decl(relationDepthSharedCheckOrder.ts, 228, 16)) +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) + +interface J111 { next: J112 } +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) +>next : Symbol(J111.next, Decl(relationDepthSharedCheckOrder.ts, 229, 16)) +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) + +interface I112 { next: I113 } +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) +>next : Symbol(I112.next, Decl(relationDepthSharedCheckOrder.ts, 230, 16)) +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) + +interface J112 { next: J113 } +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) +>next : Symbol(J112.next, Decl(relationDepthSharedCheckOrder.ts, 231, 16)) +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) + +interface I113 { next: I114 } +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) +>next : Symbol(I113.next, Decl(relationDepthSharedCheckOrder.ts, 232, 16)) +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) + +interface J113 { next: J114 } +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) +>next : Symbol(J113.next, Decl(relationDepthSharedCheckOrder.ts, 233, 16)) +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) + +interface I114 { next: I115 } +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) +>next : Symbol(I114.next, Decl(relationDepthSharedCheckOrder.ts, 234, 16)) +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) + +interface J114 { next: J115 } +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) +>next : Symbol(J114.next, Decl(relationDepthSharedCheckOrder.ts, 235, 16)) +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) + +interface I115 { next: I116 } +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) +>next : Symbol(I115.next, Decl(relationDepthSharedCheckOrder.ts, 236, 16)) +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) + +interface J115 { next: J116 } +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) +>next : Symbol(J115.next, Decl(relationDepthSharedCheckOrder.ts, 237, 16)) +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) + +interface I116 { next: I117 } +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) +>next : Symbol(I116.next, Decl(relationDepthSharedCheckOrder.ts, 238, 16)) +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) + +interface J116 { next: J117 } +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) +>next : Symbol(J116.next, Decl(relationDepthSharedCheckOrder.ts, 239, 16)) +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) + +interface I117 { next: I118 } +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) +>next : Symbol(I117.next, Decl(relationDepthSharedCheckOrder.ts, 240, 16)) +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) + +interface J117 { next: J118 } +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) +>next : Symbol(J117.next, Decl(relationDepthSharedCheckOrder.ts, 241, 16)) +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) + +interface I118 { next: I119 } +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) +>next : Symbol(I118.next, Decl(relationDepthSharedCheckOrder.ts, 242, 16)) +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) + +interface J118 { next: J119 } +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) +>next : Symbol(J118.next, Decl(relationDepthSharedCheckOrder.ts, 243, 16)) +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) + +interface I119 { leaf: string } +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) +>leaf : Symbol(I119.leaf, Decl(relationDepthSharedCheckOrder.ts, 244, 16)) + +interface J119 { leaf: number } +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) +>leaf : Symbol(J119.leaf, Decl(relationDepthSharedCheckOrder.ts, 245, 16)) + +type Mid = I60 extends J60 ? true : false; +>Mid : Symbol(Mid, Decl(relationDepthSharedCheckOrder.ts, 245, 31)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +type All = I0 extends J0 ? true : false; +>All : Symbol(All, Decl(relationDepthSharedCheckOrder.ts, 247, 42)) +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..2fbf00669bb64 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,739 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>next : I1 + +interface J0 { next: J1 } +>next : J1 + +interface I1 { next: I2 } +>next : I2 + +interface J1 { next: J2 } +>next : J2 + +interface I2 { next: I3 } +>next : I3 + +interface J2 { next: J3 } +>next : J3 + +interface I3 { next: I4 } +>next : I4 + +interface J3 { next: J4 } +>next : J4 + +interface I4 { next: I5 } +>next : I5 + +interface J4 { next: J5 } +>next : J5 + +interface I5 { next: I6 } +>next : I6 + +interface J5 { next: J6 } +>next : J6 + +interface I6 { next: I7 } +>next : I7 + +interface J6 { next: J7 } +>next : J7 + +interface I7 { next: I8 } +>next : I8 + +interface J7 { next: J8 } +>next : J8 + +interface I8 { next: I9 } +>next : I9 + +interface J8 { next: J9 } +>next : J9 + +interface I9 { next: I10 } +>next : I10 + +interface J9 { next: J10 } +>next : J10 + +interface I10 { next: I11 } +>next : I11 + +interface J10 { next: J11 } +>next : J11 + +interface I11 { next: I12 } +>next : I12 + +interface J11 { next: J12 } +>next : J12 + +interface I12 { next: I13 } +>next : I13 + +interface J12 { next: J13 } +>next : J13 + +interface I13 { next: I14 } +>next : I14 + +interface J13 { next: J14 } +>next : J14 + +interface I14 { next: I15 } +>next : I15 + +interface J14 { next: J15 } +>next : J15 + +interface I15 { next: I16 } +>next : I16 + +interface J15 { next: J16 } +>next : J16 + +interface I16 { next: I17 } +>next : I17 + +interface J16 { next: J17 } +>next : J17 + +interface I17 { next: I18 } +>next : I18 + +interface J17 { next: J18 } +>next : J18 + +interface I18 { next: I19 } +>next : I19 + +interface J18 { next: J19 } +>next : J19 + +interface I19 { next: I20 } +>next : I20 + +interface J19 { next: J20 } +>next : J20 + +interface I20 { next: I21 } +>next : I21 + +interface J20 { next: J21 } +>next : J21 + +interface I21 { next: I22 } +>next : I22 + +interface J21 { next: J22 } +>next : J22 + +interface I22 { next: I23 } +>next : I23 + +interface J22 { next: J23 } +>next : J23 + +interface I23 { next: I24 } +>next : I24 + +interface J23 { next: J24 } +>next : J24 + +interface I24 { next: I25 } +>next : I25 + +interface J24 { next: J25 } +>next : J25 + +interface I25 { next: I26 } +>next : I26 + +interface J25 { next: J26 } +>next : J26 + +interface I26 { next: I27 } +>next : I27 + +interface J26 { next: J27 } +>next : J27 + +interface I27 { next: I28 } +>next : I28 + +interface J27 { next: J28 } +>next : J28 + +interface I28 { next: I29 } +>next : I29 + +interface J28 { next: J29 } +>next : J29 + +interface I29 { next: I30 } +>next : I30 + +interface J29 { next: J30 } +>next : J30 + +interface I30 { next: I31 } +>next : I31 + +interface J30 { next: J31 } +>next : J31 + +interface I31 { next: I32 } +>next : I32 + +interface J31 { next: J32 } +>next : J32 + +interface I32 { next: I33 } +>next : I33 + +interface J32 { next: J33 } +>next : J33 + +interface I33 { next: I34 } +>next : I34 + +interface J33 { next: J34 } +>next : J34 + +interface I34 { next: I35 } +>next : I35 + +interface J34 { next: J35 } +>next : J35 + +interface I35 { next: I36 } +>next : I36 + +interface J35 { next: J36 } +>next : J36 + +interface I36 { next: I37 } +>next : I37 + +interface J36 { next: J37 } +>next : J37 + +interface I37 { next: I38 } +>next : I38 + +interface J37 { next: J38 } +>next : J38 + +interface I38 { next: I39 } +>next : I39 + +interface J38 { next: J39 } +>next : J39 + +interface I39 { next: I40 } +>next : I40 + +interface J39 { next: J40 } +>next : J40 + +interface I40 { next: I41 } +>next : I41 + +interface J40 { next: J41 } +>next : J41 + +interface I41 { next: I42 } +>next : I42 + +interface J41 { next: J42 } +>next : J42 + +interface I42 { next: I43 } +>next : I43 + +interface J42 { next: J43 } +>next : J43 + +interface I43 { next: I44 } +>next : I44 + +interface J43 { next: J44 } +>next : J44 + +interface I44 { next: I45 } +>next : I45 + +interface J44 { next: J45 } +>next : J45 + +interface I45 { next: I46 } +>next : I46 + +interface J45 { next: J46 } +>next : J46 + +interface I46 { next: I47 } +>next : I47 + +interface J46 { next: J47 } +>next : J47 + +interface I47 { next: I48 } +>next : I48 + +interface J47 { next: J48 } +>next : J48 + +interface I48 { next: I49 } +>next : I49 + +interface J48 { next: J49 } +>next : J49 + +interface I49 { next: I50 } +>next : I50 + +interface J49 { next: J50 } +>next : J50 + +interface I50 { next: I51 } +>next : I51 + +interface J50 { next: J51 } +>next : J51 + +interface I51 { next: I52 } +>next : I52 + +interface J51 { next: J52 } +>next : J52 + +interface I52 { next: I53 } +>next : I53 + +interface J52 { next: J53 } +>next : J53 + +interface I53 { next: I54 } +>next : I54 + +interface J53 { next: J54 } +>next : J54 + +interface I54 { next: I55 } +>next : I55 + +interface J54 { next: J55 } +>next : J55 + +interface I55 { next: I56 } +>next : I56 + +interface J55 { next: J56 } +>next : J56 + +interface I56 { next: I57 } +>next : I57 + +interface J56 { next: J57 } +>next : J57 + +interface I57 { next: I58 } +>next : I58 + +interface J57 { next: J58 } +>next : J58 + +interface I58 { next: I59 } +>next : I59 + +interface J58 { next: J59 } +>next : J59 + +interface I59 { next: I60 } +>next : I60 + +interface J59 { next: J60 } +>next : J60 + +interface I60 { next: I61 } +>next : I61 + +interface J60 { next: J61 } +>next : J61 + +interface I61 { next: I62 } +>next : I62 + +interface J61 { next: J62 } +>next : J62 + +interface I62 { next: I63 } +>next : I63 + +interface J62 { next: J63 } +>next : J63 + +interface I63 { next: I64 } +>next : I64 + +interface J63 { next: J64 } +>next : J64 + +interface I64 { next: I65 } +>next : I65 + +interface J64 { next: J65 } +>next : J65 + +interface I65 { next: I66 } +>next : I66 + +interface J65 { next: J66 } +>next : J66 + +interface I66 { next: I67 } +>next : I67 + +interface J66 { next: J67 } +>next : J67 + +interface I67 { next: I68 } +>next : I68 + +interface J67 { next: J68 } +>next : J68 + +interface I68 { next: I69 } +>next : I69 + +interface J68 { next: J69 } +>next : J69 + +interface I69 { next: I70 } +>next : I70 + +interface J69 { next: J70 } +>next : J70 + +interface I70 { next: I71 } +>next : I71 + +interface J70 { next: J71 } +>next : J71 + +interface I71 { next: I72 } +>next : I72 + +interface J71 { next: J72 } +>next : J72 + +interface I72 { next: I73 } +>next : I73 + +interface J72 { next: J73 } +>next : J73 + +interface I73 { next: I74 } +>next : I74 + +interface J73 { next: J74 } +>next : J74 + +interface I74 { next: I75 } +>next : I75 + +interface J74 { next: J75 } +>next : J75 + +interface I75 { next: I76 } +>next : I76 + +interface J75 { next: J76 } +>next : J76 + +interface I76 { next: I77 } +>next : I77 + +interface J76 { next: J77 } +>next : J77 + +interface I77 { next: I78 } +>next : I78 + +interface J77 { next: J78 } +>next : J78 + +interface I78 { next: I79 } +>next : I79 + +interface J78 { next: J79 } +>next : J79 + +interface I79 { next: I80 } +>next : I80 + +interface J79 { next: J80 } +>next : J80 + +interface I80 { next: I81 } +>next : I81 + +interface J80 { next: J81 } +>next : J81 + +interface I81 { next: I82 } +>next : I82 + +interface J81 { next: J82 } +>next : J82 + +interface I82 { next: I83 } +>next : I83 + +interface J82 { next: J83 } +>next : J83 + +interface I83 { next: I84 } +>next : I84 + +interface J83 { next: J84 } +>next : J84 + +interface I84 { next: I85 } +>next : I85 + +interface J84 { next: J85 } +>next : J85 + +interface I85 { next: I86 } +>next : I86 + +interface J85 { next: J86 } +>next : J86 + +interface I86 { next: I87 } +>next : I87 + +interface J86 { next: J87 } +>next : J87 + +interface I87 { next: I88 } +>next : I88 + +interface J87 { next: J88 } +>next : J88 + +interface I88 { next: I89 } +>next : I89 + +interface J88 { next: J89 } +>next : J89 + +interface I89 { next: I90 } +>next : I90 + +interface J89 { next: J90 } +>next : J90 + +interface I90 { next: I91 } +>next : I91 + +interface J90 { next: J91 } +>next : J91 + +interface I91 { next: I92 } +>next : I92 + +interface J91 { next: J92 } +>next : J92 + +interface I92 { next: I93 } +>next : I93 + +interface J92 { next: J93 } +>next : J93 + +interface I93 { next: I94 } +>next : I94 + +interface J93 { next: J94 } +>next : J94 + +interface I94 { next: I95 } +>next : I95 + +interface J94 { next: J95 } +>next : J95 + +interface I95 { next: I96 } +>next : I96 + +interface J95 { next: J96 } +>next : J96 + +interface I96 { next: I97 } +>next : I97 + +interface J96 { next: J97 } +>next : J97 + +interface I97 { next: I98 } +>next : I98 + +interface J97 { next: J98 } +>next : J98 + +interface I98 { next: I99 } +>next : I99 + +interface J98 { next: J99 } +>next : J99 + +interface I99 { next: I100 } +>next : I100 + +interface J99 { next: J100 } +>next : J100 + +interface I100 { next: I101 } +>next : I101 + +interface J100 { next: J101 } +>next : J101 + +interface I101 { next: I102 } +>next : I102 + +interface J101 { next: J102 } +>next : J102 + +interface I102 { next: I103 } +>next : I103 + +interface J102 { next: J103 } +>next : J103 + +interface I103 { next: I104 } +>next : I104 + +interface J103 { next: J104 } +>next : J104 + +interface I104 { next: I105 } +>next : I105 + +interface J104 { next: J105 } +>next : J105 + +interface I105 { next: I106 } +>next : I106 + +interface J105 { next: J106 } +>next : J106 + +interface I106 { next: I107 } +>next : I107 + +interface J106 { next: J107 } +>next : J107 + +interface I107 { next: I108 } +>next : I108 + +interface J107 { next: J108 } +>next : J108 + +interface I108 { next: I109 } +>next : I109 + +interface J108 { next: J109 } +>next : J109 + +interface I109 { next: I110 } +>next : I110 + +interface J109 { next: J110 } +>next : J110 + +interface I110 { next: I111 } +>next : I111 + +interface J110 { next: J111 } +>next : J111 + +interface I111 { next: I112 } +>next : I112 + +interface J111 { next: J112 } +>next : J112 + +interface I112 { next: I113 } +>next : I113 + +interface J112 { next: J113 } +>next : J113 + +interface I113 { next: I114 } +>next : I114 + +interface J113 { next: J114 } +>next : J114 + +interface I114 { next: I115 } +>next : I115 + +interface J114 { next: J115 } +>next : J115 + +interface I115 { next: I116 } +>next : I116 + +interface J115 { next: J116 } +>next : J116 + +interface I116 { next: I117 } +>next : I117 + +interface J116 { next: J117 } +>next : J117 + +interface I117 { next: I118 } +>next : I118 + +interface J117 { next: J118 } +>next : J118 + +interface I118 { next: I119 } +>next : I119 + +interface J118 { next: J119 } +>next : J119 + +interface I119 { leaf: string } +>leaf : string + +interface J119 { leaf: number } +>leaf : number + +type Mid = I60 extends J60 ? true : false; +>Mid : false +>true : true +>false : false + +type All = I0 extends J0 ? true : false; +>All : true +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt new file mode 100644 index 0000000000000..959e47bf00a94 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt @@ -0,0 +1,28 @@ +relationMaybeCheckOrder.ts(8,32): error TS2322: Type 'B' is not assignable to type 'string | number | symbol'. + + +==== relationMaybeCheckOrder.ts (1 errors) ==== + // Relating to 'keyof M' rejects keys that relate only by assuming a + // comparison still in progress. Relating 'A' to 'B' assumes only itself + // along 'next', so it completes on its own and must be accepted whether + // or not the call to 'h' related 'A' to 'B' first. + + interface A { next: A; v: "a" } + interface B { next: B; v: string } + type M = { [K in keyof T as B]: 1 }; + ~ +!!! error TS2322: Type 'B' is not assignable to type 'string | number | symbol'. + + declare const a: A; + declare function h(x: B): 1; + declare function h(x: unknown): 2; + + function f() { + function g(x: keyof M): 1; + function g(x: unknown): 2; + function g(x: unknown) { return 1 as any; } + const r: 1 = g(a); + } + + const w: 1 = h(a); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.symbols b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.symbols new file mode 100644 index 0000000000000..c577599a23c3c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/relationMaybeCheckOrder.ts] //// + +=== relationMaybeCheckOrder.ts === +// Relating to 'keyof M' rejects keys that relate only by assuming a +// comparison still in progress. Relating 'A' to 'B' assumes only itself +// along 'next', so it completes on its own and must be accepted whether +// or not the call to 'h' related 'A' to 'B' first. + +interface A { next: A; v: "a" } +>A : Symbol(A, Decl(relationMaybeCheckOrder.ts, 0, 0)) +>next : Symbol(A.next, Decl(relationMaybeCheckOrder.ts, 5, 13)) +>A : Symbol(A, Decl(relationMaybeCheckOrder.ts, 0, 0)) +>v : Symbol(A.v, Decl(relationMaybeCheckOrder.ts, 5, 22)) + +interface B { next: B; v: string } +>B : Symbol(B, Decl(relationMaybeCheckOrder.ts, 5, 31)) +>next : Symbol(B.next, Decl(relationMaybeCheckOrder.ts, 6, 13)) +>B : Symbol(B, Decl(relationMaybeCheckOrder.ts, 5, 31)) +>v : Symbol(B.v, Decl(relationMaybeCheckOrder.ts, 6, 22)) + +type M = { [K in keyof T as B]: 1 }; +>M : Symbol(M, Decl(relationMaybeCheckOrder.ts, 6, 34)) +>T : Symbol(T, Decl(relationMaybeCheckOrder.ts, 7, 7)) +>K : Symbol(K, Decl(relationMaybeCheckOrder.ts, 7, 15)) +>T : Symbol(T, Decl(relationMaybeCheckOrder.ts, 7, 7)) +>B : Symbol(B, Decl(relationMaybeCheckOrder.ts, 5, 31)) + +declare const a: A; +>a : Symbol(a, Decl(relationMaybeCheckOrder.ts, 9, 13)) +>A : Symbol(A, Decl(relationMaybeCheckOrder.ts, 0, 0)) + +declare function h(x: B): 1; +>h : Symbol(h, Decl(relationMaybeCheckOrder.ts, 9, 19), Decl(relationMaybeCheckOrder.ts, 10, 28)) +>x : Symbol(x, Decl(relationMaybeCheckOrder.ts, 10, 19)) +>B : Symbol(B, Decl(relationMaybeCheckOrder.ts, 5, 31)) + +declare function h(x: unknown): 2; +>h : Symbol(h, Decl(relationMaybeCheckOrder.ts, 9, 19), Decl(relationMaybeCheckOrder.ts, 10, 28)) +>x : Symbol(x, Decl(relationMaybeCheckOrder.ts, 11, 19)) + +function f() { +>f : Symbol(f, Decl(relationMaybeCheckOrder.ts, 11, 34)) +>T : Symbol(T, Decl(relationMaybeCheckOrder.ts, 13, 11)) + + function g(x: keyof M): 1; +>g : Symbol(g, Decl(relationMaybeCheckOrder.ts, 13, 17), Decl(relationMaybeCheckOrder.ts, 14, 33), Decl(relationMaybeCheckOrder.ts, 15, 30)) +>x : Symbol(x, Decl(relationMaybeCheckOrder.ts, 14, 15)) +>M : Symbol(M, Decl(relationMaybeCheckOrder.ts, 6, 34)) +>T : Symbol(T, Decl(relationMaybeCheckOrder.ts, 13, 11)) + + function g(x: unknown): 2; +>g : Symbol(g, Decl(relationMaybeCheckOrder.ts, 13, 17), Decl(relationMaybeCheckOrder.ts, 14, 33), Decl(relationMaybeCheckOrder.ts, 15, 30)) +>x : Symbol(x, Decl(relationMaybeCheckOrder.ts, 15, 15)) + + function g(x: unknown) { return 1 as any; } +>g : Symbol(g, Decl(relationMaybeCheckOrder.ts, 13, 17), Decl(relationMaybeCheckOrder.ts, 14, 33), Decl(relationMaybeCheckOrder.ts, 15, 30)) +>x : Symbol(x, Decl(relationMaybeCheckOrder.ts, 16, 15)) + + const r: 1 = g(a); +>r : Symbol(r, Decl(relationMaybeCheckOrder.ts, 17, 9)) +>g : Symbol(g, Decl(relationMaybeCheckOrder.ts, 13, 17), Decl(relationMaybeCheckOrder.ts, 14, 33), Decl(relationMaybeCheckOrder.ts, 15, 30)) +>a : Symbol(a, Decl(relationMaybeCheckOrder.ts, 9, 13)) +} + +const w: 1 = h(a); +>w : Symbol(w, Decl(relationMaybeCheckOrder.ts, 20, 5)) +>h : Symbol(h, Decl(relationMaybeCheckOrder.ts, 9, 19), Decl(relationMaybeCheckOrder.ts, 10, 28)) +>a : Symbol(a, Decl(relationMaybeCheckOrder.ts, 9, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types new file mode 100644 index 0000000000000..79fb5d6072b67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types @@ -0,0 +1,60 @@ +//// [tests/cases/compiler/relationMaybeCheckOrder.ts] //// + +=== relationMaybeCheckOrder.ts === +// Relating to 'keyof M' rejects keys that relate only by assuming a +// comparison still in progress. Relating 'A' to 'B' assumes only itself +// along 'next', so it completes on its own and must be accepted whether +// or not the call to 'h' related 'A' to 'B' first. + +interface A { next: A; v: "a" } +>next : A +>v : "a" + +interface B { next: B; v: string } +>next : B +>v : string + +type M = { [K in keyof T as B]: 1 }; +>M : M + +declare const a: A; +>a : A + +declare function h(x: B): 1; +>h : { (x: B): 1; (x: unknown): 2; } +>x : B + +declare function h(x: unknown): 2; +>h : { (x: B): 1; (x: unknown): 2; } +>x : unknown + +function f() { +>f : () => void + + function g(x: keyof M): 1; +>g : { (x: keyof M): 1; (x: unknown): 2; } +>x : keyof M + + function g(x: unknown): 2; +>g : { (x: keyof M): 1; (x: unknown): 2; } +>x : unknown + + function g(x: unknown) { return 1 as any; } +>g : { (x: keyof M): 1; (x: unknown): 2; } +>x : unknown +>1 as any : any +>1 : 1 + + const r: 1 = g(a); +>r : 1 +>g(a) : 1 +>g : { (x: keyof M): 1; (x: unknown): 2; } +>a : A +} + +const w: 1 = h(a); +>w : 1 +>h(a) : 1 +>h : { (x: B): 1; (x: unknown): 2; } +>a : A + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..337f9333d8214 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 6, 13)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 6, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) + +type R = { next: R<[T]>; leaf: T }; +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 7, 13)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : Symbol(Inner, Decl(relationNestingSharedCheckOrder.ts, 7, 38)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + +type Outer = S extends R ? true : false; +>Outer : Symbol(Outer, Decl(relationNestingSharedCheckOrder.ts, 9, 60)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..2eb3a955c4f06 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : S +>next : S<[T]> +>leaf : T extends [[unknown]] ? number : T + +type R = { next: R<[T]>; leaf: T }; +>R : R +>next : R<[T]> +>leaf : T + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : false +>true : true +>false : false + +type Outer = S extends R ? true : false; +>Outer : false +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..337f9333d8214 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 6, 13)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 6, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) + +type R = { next: R<[T]>; leaf: T }; +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 7, 13)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : Symbol(Inner, Decl(relationNestingSharedCheckOrder.ts, 7, 38)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + +type Outer = S extends R ? true : false; +>Outer : Symbol(Outer, Decl(relationNestingSharedCheckOrder.ts, 9, 60)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..af0850b02eb7b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : S +>next : S<[T]> +>leaf : T extends [[unknown]] ? number : T + +type R = { next: R<[T]>; leaf: T }; +>R : R +>next : R<[T]> +>leaf : T + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : false +>true : true +>false : false + +type Outer = S extends R ? true : false; +>Outer : true +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..8b543f32384ea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,25 @@ +relationTruncatedCacheCheckOrder.ts(14,1): error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. + The types of 'next.leaf' are incompatible between these types. + Type 'number' is not assignable to type '[[string]]'. + + +==== relationTruncatedCacheCheckOrder.ts (1 errors) ==== + // Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' + // before giving up on deeply nested types, and fails there. Inside the + // relation of 'S' to 'R' it is one level deeper and is cut + // short instead. That truncated result must not be cached, so the error for + // 'q = p' must be reported whether or not 'y = x' was checked first. + + type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; + type R = { next: R<[T]>; leaf: T }; + + declare let x: S, y: R; + declare let p: S<[string]>, q: R<[string]>; + + y = x; + q = p; + ~ +!!! error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. +!!! error TS2322: The types of 'next.leaf' are incompatible between these types. +!!! error TS2322: Type 'number' is not assignable to type '[[string]]'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..1a917a7da7f9f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).symbols @@ -0,0 +1,48 @@ +//// [tests/cases/compiler/relationTruncatedCacheCheckOrder.ts] //// + +=== relationTruncatedCacheCheckOrder.ts === +// Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' +// before giving up on deeply nested types, and fails there. Inside the +// relation of 'S' to 'R' it is one level deeper and is cut +// short instead. That truncated result must not be cached, so the error for +// 'q = p' must be reported whether or not 'y = x' was checked first. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>next : Symbol(next, Decl(relationTruncatedCacheCheckOrder.ts, 6, 13)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>leaf : Symbol(leaf, Decl(relationTruncatedCacheCheckOrder.ts, 6, 27)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) + +type R = { next: R<[T]>; leaf: T }; +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) +>next : Symbol(next, Decl(relationTruncatedCacheCheckOrder.ts, 7, 13)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) +>leaf : Symbol(leaf, Decl(relationTruncatedCacheCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) + +declare let x: S, y: R; +>x : Symbol(x, Decl(relationTruncatedCacheCheckOrder.ts, 9, 11)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>y : Symbol(y, Decl(relationTruncatedCacheCheckOrder.ts, 9, 25)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) + +declare let p: S<[string]>, q: R<[string]>; +>p : Symbol(p, Decl(relationTruncatedCacheCheckOrder.ts, 10, 11)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>q : Symbol(q, Decl(relationTruncatedCacheCheckOrder.ts, 10, 27)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) + +y = x; +>y : Symbol(y, Decl(relationTruncatedCacheCheckOrder.ts, 9, 25)) +>x : Symbol(x, Decl(relationTruncatedCacheCheckOrder.ts, 9, 11)) + +q = p; +>q : Symbol(q, Decl(relationTruncatedCacheCheckOrder.ts, 10, 27)) +>p : Symbol(p, Decl(relationTruncatedCacheCheckOrder.ts, 10, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..61db4cbc7e0c8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/relationTruncatedCacheCheckOrder.ts] //// + +=== relationTruncatedCacheCheckOrder.ts === +// Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' +// before giving up on deeply nested types, and fails there. Inside the +// relation of 'S' to 'R' it is one level deeper and is cut +// short instead. That truncated result must not be cached, so the error for +// 'q = p' must be reported whether or not 'y = x' was checked first. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : S +>next : S<[T]> +>leaf : T extends [[unknown]] ? number : T + +type R = { next: R<[T]>; leaf: T }; +>R : R +>next : R<[T]> +>leaf : T + +declare let x: S, y: R; +>x : S +>y : R + +declare let p: S<[string]>, q: R<[string]>; +>p : S<[string]> +>q : R<[string]> + +y = x; +>y = x : S +>y : R +>x : S + +q = p; +>q = p : S<[string]> +>q : R<[string]> +>p : S<[string]> + diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..8b543f32384ea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,25 @@ +relationTruncatedCacheCheckOrder.ts(14,1): error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. + The types of 'next.leaf' are incompatible between these types. + Type 'number' is not assignable to type '[[string]]'. + + +==== relationTruncatedCacheCheckOrder.ts (1 errors) ==== + // Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' + // before giving up on deeply nested types, and fails there. Inside the + // relation of 'S' to 'R' it is one level deeper and is cut + // short instead. That truncated result must not be cached, so the error for + // 'q = p' must be reported whether or not 'y = x' was checked first. + + type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; + type R = { next: R<[T]>; leaf: T }; + + declare let x: S, y: R; + declare let p: S<[string]>, q: R<[string]>; + + y = x; + q = p; + ~ +!!! error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. +!!! error TS2322: The types of 'next.leaf' are incompatible between these types. +!!! error TS2322: Type 'number' is not assignable to type '[[string]]'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..1a917a7da7f9f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,48 @@ +//// [tests/cases/compiler/relationTruncatedCacheCheckOrder.ts] //// + +=== relationTruncatedCacheCheckOrder.ts === +// Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' +// before giving up on deeply nested types, and fails there. Inside the +// relation of 'S' to 'R' it is one level deeper and is cut +// short instead. That truncated result must not be cached, so the error for +// 'q = p' must be reported whether or not 'y = x' was checked first. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>next : Symbol(next, Decl(relationTruncatedCacheCheckOrder.ts, 6, 13)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>leaf : Symbol(leaf, Decl(relationTruncatedCacheCheckOrder.ts, 6, 27)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) + +type R = { next: R<[T]>; leaf: T }; +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) +>next : Symbol(next, Decl(relationTruncatedCacheCheckOrder.ts, 7, 13)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) +>leaf : Symbol(leaf, Decl(relationTruncatedCacheCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) + +declare let x: S, y: R; +>x : Symbol(x, Decl(relationTruncatedCacheCheckOrder.ts, 9, 11)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>y : Symbol(y, Decl(relationTruncatedCacheCheckOrder.ts, 9, 25)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) + +declare let p: S<[string]>, q: R<[string]>; +>p : Symbol(p, Decl(relationTruncatedCacheCheckOrder.ts, 10, 11)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>q : Symbol(q, Decl(relationTruncatedCacheCheckOrder.ts, 10, 27)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) + +y = x; +>y : Symbol(y, Decl(relationTruncatedCacheCheckOrder.ts, 9, 25)) +>x : Symbol(x, Decl(relationTruncatedCacheCheckOrder.ts, 9, 11)) + +q = p; +>q : Symbol(q, Decl(relationTruncatedCacheCheckOrder.ts, 10, 27)) +>p : Symbol(p, Decl(relationTruncatedCacheCheckOrder.ts, 10, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..61db4cbc7e0c8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/relationTruncatedCacheCheckOrder.ts] //// + +=== relationTruncatedCacheCheckOrder.ts === +// Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' +// before giving up on deeply nested types, and fails there. Inside the +// relation of 'S' to 'R' it is one level deeper and is cut +// short instead. That truncated result must not be cached, so the error for +// 'q = p' must be reported whether or not 'y = x' was checked first. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : S +>next : S<[T]> +>leaf : T extends [[unknown]] ? number : T + +type R = { next: R<[T]>; leaf: T }; +>R : R +>next : R<[T]> +>leaf : T + +declare let x: S, y: R; +>x : S +>y : R + +declare let p: S<[string]>, q: R<[string]>; +>p : S<[string]> +>q : R<[string]> + +y = x; +>y = x : S +>y : R +>x : S + +q = p; +>q = p : S<[string]> +>q : R<[string]> +>p : S<[string]> + diff --git a/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.symbols b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.symbols new file mode 100644 index 0000000000000..bb4e995330087 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.symbols @@ -0,0 +1,682 @@ +//// [tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts] //// + +=== arraySlice.d.ts === +export type {ArraySlice}; +>ArraySlice : Symbol(ArraySlice, Decl(arraySlice.d.ts, 0, 13)) + +declare const tag: unique symbol; +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) + +type IsNever = [T] extends [never] ? true : false; +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>T : Symbol(T, Decl(arraySlice.d.ts, 2, 13)) +>T : Symbol(T, Decl(arraySlice.d.ts, 2, 13)) + +type IsEqual = +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) + + [A] extends [B] +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) + + ? [B] extends [A] +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) + + ? _IsEqual +>_IsEqual : Symbol(_IsEqual, Decl(arraySlice.d.ts, 8, 10)) +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) + + : false + : false; +type _IsEqual = never; +>_IsEqual : Symbol(_IsEqual, Decl(arraySlice.d.ts, 8, 10)) +>A : Symbol(A, Decl(arraySlice.d.ts, 9, 14)) +>B : Symbol(B, Decl(arraySlice.d.ts, 9, 16)) + +type Primitive = +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + + | null + | undefined + | string + | number + | boolean + | symbol + | bigint; +type UnknownArray = any; +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type IfNotAnyOrNever = +>IfNotAnyOrNever : Symbol(IfNotAnyOrNever, Decl(arraySlice.d.ts, 18, 24)) +>T : Symbol(T, Decl(arraySlice.d.ts, 19, 21)) +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) +>ifNot : Symbol(ifNot, Decl(arraySlice.d.ts, 19, 39)) +>ifAny : Symbol(ifAny, Decl(arraySlice.d.ts, 19, 54)) +>ifNever : Symbol(ifNever, Decl(arraySlice.d.ts, 19, 71)) + + IsNever extends true +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>T : Symbol(T, Decl(arraySlice.d.ts, 19, 21)) + + ? 'ifNever' extends keyof Cases +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) + + ? Cases['ifNever'] +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) + + : never + : Cases['ifNot']; +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) + +type And = B; +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>A : Symbol(A, Decl(arraySlice.d.ts, 25, 9)) +>B : Symbol(B, Decl(arraySlice.d.ts, 25, 27)) +>B : Symbol(B, Decl(arraySlice.d.ts, 25, 27)) + +type Not = any; +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>A : Symbol(A, Decl(arraySlice.d.ts, 26, 9)) + +type MaxLength = never; +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 27, 15)) +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type HasNoStaticElements = unknown; +>HasNoStaticElements : Symbol(HasNoStaticElements, Decl(arraySlice.d.ts, 27, 52)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 28, 25)) +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type CollapseLiterals = Union extends Primitive +>CollapseLiterals : Symbol(CollapseLiterals, Decl(arraySlice.d.ts, 28, 64)) +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + + ? Union extends infer Collapsed & {} +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) +>Collapsed : Symbol(Collapsed, Decl(arraySlice.d.ts, 30, 22)) + + ? Collapsed +>Collapsed : Symbol(Collapsed, Decl(arraySlice.d.ts, 30, 22)) + + : Union +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) + + : Union; +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) + +type PositiveNumericStringGt = A; +>PositiveNumericStringGt : Symbol(PositiveNumericStringGt, Decl(arraySlice.d.ts, 33, 9)) +>A : Symbol(A, Decl(arraySlice.d.ts, 34, 29)) +>B : Symbol(B, Decl(arraySlice.d.ts, 34, 46)) +>A : Symbol(A, Decl(arraySlice.d.ts, 34, 29)) + +type Absolute = _Absolute : N>; +>Absolute : Symbol(Absolute, Decl(arraySlice.d.ts, 34, 69)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) +>_Absolute : Symbol(_Absolute, Decl(arraySlice.d.ts, 35, 92)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) + +type _Absolute = N extends bigint +>_Absolute : Symbol(_Absolute, Decl(arraySlice.d.ts, 35, 92)) +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + + ? `${N}` extends `-${infer Magnitude extends bigint}` +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 37, 27)) + + ? Magnitude +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 37, 27)) + + : N +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + + : `${N}` extends `-${infer Magnitude extends number}` +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 40, 27)) + + ? Magnitude +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 40, 27)) + + : `${N}` extends '-Infinity' +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + + ? PositiveInfinity +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + : `${number}` extends `${N}` ? number : N; +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + +type GreaterThan = +>GreaterThan : Symbol(GreaterThan, Decl(arraySlice.d.ts, 44, 45)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + _GreaterThan : A, B extends object ? UnwrapBrand : B>; +>_GreaterThan : Symbol(_GreaterThan, Decl(arraySlice.d.ts, 46, 92)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) + +type _GreaterThan = +>_GreaterThan : Symbol(_GreaterThan, Decl(arraySlice.d.ts, 46, 92)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + A extends _Numeric +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + ? B extends _Numeric +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + ? `${number}` extends `${A | B}` +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) + + ? boolean + : bigint extends A | B +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) + + ? boolean + : A extends PositiveInfinity +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + ? B extends PositiveInfinity ? false : true +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + : B extends NegativeInfinity +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + + ? A extends NegativeInfinity ? false : true +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + + : A extends NegativeInfinity +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + + ? false + : B extends PositiveInfinity +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + ? false + : [IsNegative, IsNegative] extends infer Signs extends [boolean, boolean] +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? [true, false] extends Signs +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? false + : [false, true] extends Signs +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? true + : [false, false] extends Signs +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? PositiveNumericStringGt<`${A}`, `${B}`> +>PositiveNumericStringGt : Symbol(PositiveNumericStringGt, Decl(arraySlice.d.ts, 33, 9)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) + + : PositiveNumericStringGt<`${Absolute}`, `${Absolute}`> +>PositiveNumericStringGt : Symbol(PositiveNumericStringGt, Decl(arraySlice.d.ts, 33, 9)) +>Absolute : Symbol(Absolute, Decl(arraySlice.d.ts, 34, 69)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>Absolute : Symbol(Absolute, Decl(arraySlice.d.ts, 34, 69)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) + + : never + : never + : never; +type IsReadonlyArray = never; +>IsReadonlyArray : Symbol(IsReadonlyArray, Decl(arraySlice.d.ts, 72, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 73, 21)) +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type UnionMember = +>UnionMember : Symbol(UnionMember, Decl(arraySlice.d.ts, 73, 58)) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) + + IsNever extends true +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) + + ? never + : (T extends any ? () => T : never) extends () => (infer R) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) +>R : Symbol(R, Decl(arraySlice.d.ts, 77, 58)) + + ? R +>R : Symbol(R, Decl(arraySlice.d.ts, 77, 58)) + + : never; +type TagContainer = { +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) +>Token : Symbol(Token, Decl(arraySlice.d.ts, 80, 18)) + + readonly [tag]: Token; +>[tag] : Symbol([tag], Decl(arraySlice.d.ts, 80, 28)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) +>Token : Symbol(Token, Decl(arraySlice.d.ts, 80, 18)) + +}; +type Tag = unknown; +>Tag : Symbol(Tag, Decl(arraySlice.d.ts, 82, 2)) +>TagName : Symbol(TagName, Decl(arraySlice.d.ts, 83, 9)) +>PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) +>TagMetadata : Symbol(TagMetadata, Decl(arraySlice.d.ts, 83, 37)) + +type RemoveAllTags = T extends TagContainer +>RemoveAllTags : Symbol(RemoveAllTags, Decl(arraySlice.d.ts, 83, 61)) +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) + + ? RemoveAllTags>> +>RemoveAllTags : Symbol(RemoveAllTags, Decl(arraySlice.d.ts, 83, 61)) +>UnionMember : Symbol(UnionMember, Decl(arraySlice.d.ts, 73, 58)) +>RemoveTag : Symbol(RemoveTag, Decl(arraySlice.d.ts, 86, 5)) +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) + + : T; +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) + +type RemoveTag> = +>RemoveTag : Symbol(RemoveTag, Decl(arraySlice.d.ts, 86, 5)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) + + | { + [ThisTag in keyof T[typeof tag]]: T extends infer Underlying & Tag +>ThisTag : Symbol(ThisTag, Decl(arraySlice.d.ts, 89, 3)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 89, 51)) +>Tag : Symbol(Tag, Decl(arraySlice.d.ts, 82, 2)) +>ThisTag : Symbol(ThisTag, Decl(arraySlice.d.ts, 89, 3)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) +>ThisTag : Symbol(ThisTag, Decl(arraySlice.d.ts, 89, 3)) + + ? [Underlying] extends [T] ? never : Underlying +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 89, 51)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 89, 51)) + + : never + }[keyof T[typeof tag]] +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) + + | (T extends infer Underlying & TagContainer +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 93, 19)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) + + ? [Underlying] extends [T] ? never : Underlying +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 93, 19)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 93, 19)) + + : never); +type UnwrapBrand = IfNotAnyOrNever}>; +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>T : Symbol(T, Decl(arraySlice.d.ts, 96, 17)) +>IfNotAnyOrNever : Symbol(IfNotAnyOrNever, Decl(arraySlice.d.ts, 18, 24)) +>T : Symbol(T, Decl(arraySlice.d.ts, 96, 17)) +>ifNot : Symbol(ifNot, Decl(arraySlice.d.ts, 96, 42)) +>_UnwrapBrand : Symbol(_UnwrapBrand, Decl(arraySlice.d.ts, 96, 78)) +>T : Symbol(T, Decl(arraySlice.d.ts, 96, 17)) +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + +type _UnwrapBrand = T extends Primitive +>_UnwrapBrand : Symbol(_UnwrapBrand, Decl(arraySlice.d.ts, 96, 78)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>Base : Symbol(Base, Decl(arraySlice.d.ts, 97, 20)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + + ? CollapseLiterals ? RemoveAllTags : T> +>CollapseLiterals : Symbol(CollapseLiterals, Decl(arraySlice.d.ts, 28, 64)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) +>RemoveAllTags : Symbol(RemoveAllTags, Decl(arraySlice.d.ts, 83, 61)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) + + : T; +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) + +type _Numeric = number | bigint; +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + +type PositiveInfinity = unknown; +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + +type NegativeInfinity = never; +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + +type IsNegative = never; +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>T : Symbol(T, Decl(arraySlice.d.ts, 103, 16)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + +type Sum = any; +>Sum : Symbol(Sum, Decl(arraySlice.d.ts, 103, 44)) +>A : Symbol(A, Decl(arraySlice.d.ts, 104, 9)) +>B : Symbol(B, Decl(arraySlice.d.ts, 104, 26)) + +type LessThanOrEqual = unknown; +>LessThanOrEqual : Symbol(LessThanOrEqual, Decl(arraySlice.d.ts, 104, 51)) +>A : Symbol(A, Decl(arraySlice.d.ts, 105, 21)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) +>B : Symbol(B, Decl(arraySlice.d.ts, 105, 40)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + +type ArraySlice< +>ArraySlice : Symbol(ArraySlice, Decl(arraySlice.d.ts, 105, 71)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 106, 16)) + + Start extends number = never, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) + + End extends number = never, +>End : Symbol(End, Decl(arraySlice.d.ts, 108, 30)) + +> = ArraySliceImplementation : Start, End>; +>ArraySliceImplementation : Symbol(ArraySliceImplementation, Decl(arraySlice.d.ts, 110, 93)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 106, 16)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 108, 30)) + +type ArraySliceImplementation< +>ArraySliceImplementation : Symbol(ArraySliceImplementation, Decl(arraySlice.d.ts, 110, 93)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 111, 30)) + + Start extends number, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 112, 35)) + + End extends number, +>End : Symbol(End, Decl(arraySlice.d.ts, 113, 22)) + +> = Array_ extends unknown ? _ArraySlice : never; +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 111, 30)) +>_ArraySlice : Symbol(_ArraySlice, Decl(arraySlice.d.ts, 115, 69)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 111, 30)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 112, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 113, 22)) + +type _ArraySlice< +>_ArraySlice : Symbol(_ArraySlice, Decl(arraySlice.d.ts, 115, 69)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + Start extends number = 0, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) + + End extends number = Array_['length'], +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + +> = And, IsEqual> extends true +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + + ? Array_ +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + : number extends Array_['length'] +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + ? VariableLengthArraySliceHelper extends true ? 0 : Start, End extends PositiveInfinity ? never : End> +>VariableLengthArraySliceHelper : Symbol(VariableLengthArraySliceHelper, Decl(arraySlice.d.ts, 128, 66)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + + : `${number}` extends `${Start | End}` +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + + ? UnknownLengthArraySlice +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + : ArraySliceResult extends true ? 0 : Start, IsEqual extends true ? MaxLength : End>>; +>ArraySliceResult : Symbol(ArraySliceResult, Decl(arraySlice.d.ts, 126, 164)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>ArraySliceHelper : Symbol(ArraySliceHelper, Decl(arraySlice.d.ts, 146, 70)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + +type ArraySliceResult = +>ArraySliceResult : Symbol(ArraySliceResult, Decl(arraySlice.d.ts, 126, 164)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 127, 22)) +>Sliced : Symbol(Sliced, Decl(arraySlice.d.ts, 127, 56)) + + IsReadonlyArray extends true ? Readonly : Sliced; +>IsReadonlyArray : Symbol(IsReadonlyArray, Decl(arraySlice.d.ts, 72, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 127, 22)) +>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --)) +>Sliced : Symbol(Sliced, Decl(arraySlice.d.ts, 127, 56)) +>Sliced : Symbol(Sliced, Decl(arraySlice.d.ts, 127, 56)) + +type VariableLengthArraySliceHelper< +>VariableLengthArraySliceHelper : Symbol(VariableLengthArraySliceHelper, Decl(arraySlice.d.ts, 128, 66)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + + Start extends number, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) + + End extends number, +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + +> = And< +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) + + And>, Not>>, +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + + IsEqual, true> +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>LessThanOrEqual : Symbol(LessThanOrEqual, Decl(arraySlice.d.ts, 104, 51)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) + +> extends true + ? [] + : And< +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) + + And>, Not>>, +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + + IsEqual, true> +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>GreaterThan : Symbol(GreaterThan, Decl(arraySlice.d.ts, 44, 45)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) + + > extends true + ? HasNoStaticElements extends true +>HasNoStaticElements : Symbol(HasNoStaticElements, Decl(arraySlice.d.ts, 27, 52)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + + ? UnknownLengthArraySlice +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + + : ArraySliceResult> +>ArraySliceResult : Symbol(ArraySliceResult, Decl(arraySlice.d.ts, 126, 164)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) +>ArraySliceByPositiveIndex : Symbol(ArraySliceByPositiveIndex, Decl(arraySlice.d.ts, 152, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + + : UnknownLengthArraySlice; +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + +type UnknownLengthArraySlice = any; +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 146, 29)) + +type ArraySliceHelper< +>ArraySliceHelper : Symbol(ArraySliceHelper, Decl(arraySlice.d.ts, 146, 70)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 147, 22)) + + Start extends number = 0, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 148, 35)) + + End extends number = MaxLength, +>End : Symbol(End, Decl(arraySlice.d.ts, 149, 26)) +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 147, 22)) + + ArrayLength extends number = MaxLength, +>ArrayLength : Symbol(ArrayLength, Decl(arraySlice.d.ts, 150, 40)) +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 147, 22)) + +> = never; +type ArraySliceByPositiveIndex< +>ArraySliceByPositiveIndex : Symbol(ArraySliceByPositiveIndex, Decl(arraySlice.d.ts, 152, 10)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) + + Start extends number, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) + + End extends number, +>End : Symbol(End, Decl(arraySlice.d.ts, 155, 22)) + + Result extends Array = [], +>Result : Symbol(Result, Decl(arraySlice.d.ts, 156, 20)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) + +> = Start extends End +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 155, 22)) + + ? Result +>Result : Symbol(Result, Decl(arraySlice.d.ts, 156, 20)) + + : ArraySliceByPositiveIndex, End, [...Result, Array_[Start]]>; +>ArraySliceByPositiveIndex : Symbol(ArraySliceByPositiveIndex, Decl(arraySlice.d.ts, 152, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) +>Sum : Symbol(Sum, Decl(arraySlice.d.ts, 103, 44)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 155, 22)) +>Result : Symbol(Result, Decl(arraySlice.d.ts, 156, 20)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) + +=== main.ts === +// Reduced from type-fest's ArraySlice. Inferring Value from the argument +// measures the variances of ArraySlice, which takes the restrictive +// instantiations of conditional types whose type parameters are already +// restrictive, many times over through the brand-unwrapping types. Such an +// instantiation must be the conditional type itself: making and evaluating +// a separate copy roughly triples the work, enough to exceed the +// instantiation count limit (TS2589) here. Smaller cases do not get near +// the limit either way, so the case is as large as the limit requires. +import type {ArraySlice} from './arraySlice.d.ts'; +>ArraySlice : Symbol(ArraySlice, Decl(main.ts, 8, 13)) + +declare function f(values: ArraySlice): void; +>f : Symbol(f, Decl(main.ts, 8, 50)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) +>values : Symbol(values, Decl(main.ts, 9, 26)) +>ArraySlice : Symbol(ArraySlice, Decl(main.ts, 8, 13)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) + +declare const x: ArraySlice; +>x : Symbol(x, Decl(main.ts, 10, 13)) +>ArraySlice : Symbol(ArraySlice, Decl(main.ts, 8, 13)) +>id : Symbol(id, Decl(main.ts, 10, 42)) +>id : Symbol(id, Decl(main.ts, 10, 70)) +>id : Symbol(id, Decl(main.ts, 10, 83)) + +f(x); +>f : Symbol(f, Decl(main.ts, 8, 50)) +>x : Symbol(x, Decl(main.ts, 10, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.types b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.types new file mode 100644 index 0000000000000..0a15d1aba9524 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.types @@ -0,0 +1,338 @@ +//// [tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts] //// + +=== arraySlice.d.ts === +export type {ArraySlice}; +>ArraySlice : ArraySlice + +declare const tag: unique symbol; +>tag : unique symbol + +type IsNever = [T] extends [never] ? true : false; +>IsNever : IsNever +>true : true +>false : false + +type IsEqual = +>IsEqual : IsEqual + + [A] extends [B] + ? [B] extends [A] + ? _IsEqual + : false +>false : false + + : false; +>false : false + +type _IsEqual = never; +>_IsEqual : never + +type Primitive = +>Primitive : Primitive + + | null + | undefined + | string + | number + | boolean + | symbol + | bigint; +type UnknownArray = any; +>UnknownArray : any + +type IfNotAnyOrNever = +>IfNotAnyOrNever : IfNotAnyOrNever +>ifNot : unknown +>ifAny : unknown +>ifNever : unknown + + IsNever extends true +>true : true + + ? 'ifNever' extends keyof Cases + ? Cases['ifNever'] + : never + : Cases['ifNot']; +type And = B; +>And : B + +type Not = any; +>Not : any + +type MaxLength = never; +>MaxLength : never + +type HasNoStaticElements = unknown; +>HasNoStaticElements : unknown + +type CollapseLiterals = Union extends Primitive +>CollapseLiterals : CollapseLiterals + + ? Union extends infer Collapsed & {} + ? Collapsed + : Union + : Union; +type PositiveNumericStringGt = A; +>PositiveNumericStringGt : A + +type Absolute = _Absolute : N>; +>Absolute : Absolute + +type _Absolute = N extends bigint +>_Absolute : _Absolute + + ? `${N}` extends `-${infer Magnitude extends bigint}` + ? Magnitude + : N + : `${N}` extends `-${infer Magnitude extends number}` + ? Magnitude + : `${N}` extends '-Infinity' + ? PositiveInfinity + : `${number}` extends `${N}` ? number : N; +type GreaterThan = +>GreaterThan : GreaterThan + + _GreaterThan : A, B extends object ? UnwrapBrand : B>; +type _GreaterThan = +>_GreaterThan : _GreaterThan + + A extends _Numeric + ? B extends _Numeric + ? `${number}` extends `${A | B}` + ? boolean + : bigint extends A | B + ? boolean + : A extends PositiveInfinity + ? B extends PositiveInfinity ? false : true +>false : false +>true : true + + : B extends NegativeInfinity + ? A extends NegativeInfinity ? false : true +>false : false +>true : true + + : A extends NegativeInfinity + ? false +>false : false + + : B extends PositiveInfinity + ? false +>false : false + + : [IsNegative, IsNegative] extends infer Signs extends [boolean, boolean] + ? [true, false] extends Signs +>true : true +>false : false + + ? false +>false : false + + : [false, true] extends Signs +>false : false +>true : true + + ? true +>true : true + + : [false, false] extends Signs +>false : false +>false : false + + ? PositiveNumericStringGt<`${A}`, `${B}`> + : PositiveNumericStringGt<`${Absolute}`, `${Absolute}`> + : never + : never + : never; +type IsReadonlyArray = never; +>IsReadonlyArray : never + +type UnionMember = +>UnionMember : UnionMember + + IsNever extends true +>true : true + + ? never + : (T extends any ? () => T : never) extends () => (infer R) + ? R + : never; +type TagContainer = { +>TagContainer : TagContainer + + readonly [tag]: Token; +>[tag] : Token +>tag : unique symbol + +}; +type Tag = unknown; +>Tag : unknown + +type RemoveAllTags = T extends TagContainer +>RemoveAllTags : RemoveAllTags + + ? RemoveAllTags>> + : T; +type RemoveTag> = +>RemoveTag : RemoveTag + + | { + [ThisTag in keyof T[typeof tag]]: T extends infer Underlying & Tag +>tag : unique symbol +>tag : unique symbol + + ? [Underlying] extends [T] ? never : Underlying + : never + }[keyof T[typeof tag]] +>tag : unique symbol + + | (T extends infer Underlying & TagContainer +>tag : unique symbol + + ? [Underlying] extends [T] ? never : Underlying + : never); +type UnwrapBrand = IfNotAnyOrNever}>; +>UnwrapBrand : UnwrapBrand +>ifNot : _UnwrapBrand + +type _UnwrapBrand = T extends Primitive +>_UnwrapBrand : _UnwrapBrand + + ? CollapseLiterals ? RemoveAllTags : T> + : T; +type _Numeric = number | bigint; +>_Numeric : _Numeric + +type PositiveInfinity = unknown; +>PositiveInfinity : unknown + +type NegativeInfinity = never; +>NegativeInfinity : never + +type IsNegative = never; +>IsNegative : never + +type Sum = any; +>Sum : any + +type LessThanOrEqual = unknown; +>LessThanOrEqual : unknown + +type ArraySlice< +>ArraySlice : ArraySlice + + Array_ extends readonly unknown[], + Start extends number = never, + End extends number = never, +> = ArraySliceImplementation : Start, End>; +type ArraySliceImplementation< +>ArraySliceImplementation : ArraySliceImplementation + + Array_ extends readonly unknown[], + Start extends number, + End extends number, +> = Array_ extends unknown ? _ArraySlice : never; +type _ArraySlice< +>_ArraySlice : _ArraySlice + + Array_ extends readonly unknown[], + Start extends number = 0, + End extends number = Array_['length'], +> = And, IsEqual> extends true +>true : true + + ? Array_ + : number extends Array_['length'] + ? VariableLengthArraySliceHelper extends true ? 0 : Start, End extends PositiveInfinity ? never : End> +>true : true + + : `${number}` extends `${Start | End}` + ? UnknownLengthArraySlice + : ArraySliceResult extends true ? 0 : Start, IsEqual extends true ? MaxLength : End>>; +>true : true +>true : true + +type ArraySliceResult = +>ArraySliceResult : Readonly + + IsReadonlyArray extends true ? Readonly : Sliced; +>true : true + +type VariableLengthArraySliceHelper< +>VariableLengthArraySliceHelper : IsEqual<_GreaterThan; }> : End, Start extends object ? IfNotAnyOrNever; }> : Start>, true> extends true ? Readonly> : any + + Array_ extends readonly unknown[], + Start extends number, + End extends number, +> = And< + And>, Not>>, + IsEqual, true> +>true : true + +> extends true +>true : true + + ? [] + : And< + And>, Not>>, + IsEqual, true> +>true : true + + > extends true +>true : true + + ? HasNoStaticElements extends true +>true : true + + ? UnknownLengthArraySlice + : ArraySliceResult> + : UnknownLengthArraySlice; +type UnknownLengthArraySlice = any; +>UnknownLengthArraySlice : any + +type ArraySliceHelper< +>ArraySliceHelper : never + + Array_ extends readonly unknown[], + Start extends number = 0, + End extends number = MaxLength, + ArrayLength extends number = MaxLength, +> = never; +type ArraySliceByPositiveIndex< +>ArraySliceByPositiveIndex : ArraySliceByPositiveIndex + + Array_ extends readonly unknown[], + Start extends number, + End extends number, + Result extends Array = [], +> = Start extends End + ? Result + : ArraySliceByPositiveIndex, End, [...Result, Array_[Start]]>; + +=== main.ts === +// Reduced from type-fest's ArraySlice. Inferring Value from the argument +// measures the variances of ArraySlice, which takes the restrictive +// instantiations of conditional types whose type parameters are already +// restrictive, many times over through the brand-unwrapping types. Such an +// instantiation must be the conditional type itself: making and evaluating +// a separate copy roughly triples the work, enough to exceed the +// instantiation count limit (TS2589) here. Smaller cases do not get near +// the limit either way, so the case is as large as the limit requires. +import type {ArraySlice} from './arraySlice.d.ts'; +>ArraySlice : ArraySlice + +declare function f(values: ArraySlice): void; +>f : (values: ArraySlice) => void +>values : ArraySlice + +declare const x: ArraySlice; +>x : ArraySlice +>id : "row" +>id : "row" +>id : "row" + +f(x); +>f(x) : void +>f : (values: ArraySlice) => void +>x : ArraySlice + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).js new file mode 100644 index 0000000000000..90085dfe2092f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +//// [returnTypeInferenceNotTooBroad.ts] +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +interface Opts { + low?: number; + sign?: T +} +interface Wrapper { +} +declare function sepsis(opts: Opts): Wrapper; +declare function unwrap(w: Wrapper): T; +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); + +//// [returnTypeInferenceNotTooBroad.js] +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 } }); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 } })); diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).symbols new file mode 100644 index 0000000000000..ad8e148932bab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +=== returnTypeInferenceNotTooBroad.ts === +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 14)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 0, 25)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 37)) +>b : Symbol(b, Decl(returnTypeInferenceNotTooBroad.ts, 0, 48)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 60)) +>c : Symbol(c, Decl(returnTypeInferenceNotTooBroad.ts, 0, 71)) + +interface Opts { +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) + + low?: number; +>low : Symbol(Opts.low, Decl(returnTypeInferenceNotTooBroad.ts, 1, 19)) + + sign?: T +>sign : Symbol(Opts.sign, Decl(returnTypeInferenceNotTooBroad.ts, 2, 17)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) +} +interface Wrapper { +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 5, 18)) +} +declare function sepsis(opts: Opts): Wrapper; +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>opts : Symbol(opts, Decl(returnTypeInferenceNotTooBroad.ts, 7, 41)) +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) + +declare function unwrap(w: Wrapper): T; +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>w : Symbol(w, Decl(returnTypeInferenceNotTooBroad.ts, 8, 27)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) + +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 9, 25)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 9, 33)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 9, 41)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 9, 52)) + +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +>yun : Symbol(yun, Decl(returnTypeInferenceNotTooBroad.ts, 11, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) + +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); +>yone : Symbol(yone, Decl(returnTypeInferenceNotTooBroad.ts, 13, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 13, 35)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 13, 43)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 13, 51)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 13, 62)) + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).types new file mode 100644 index 0000000000000..94962df020556 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).types @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +=== returnTypeInferenceNotTooBroad.ts === +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +>Signs : Signs +>kind : "a" +>a : 3 +>kind : "b" +>b : 2 +>kind : "c" +>c : 1 + +interface Opts { + low?: number; +>low : number | undefined + + sign?: T +>sign : T | undefined +} +interface Wrapper { +} +declare function sepsis(opts: Opts): Wrapper; +>sepsis : (opts: Opts) => Wrapper +>opts : Opts + +declare function unwrap(w: Wrapper): T; +>unwrap : (w: Wrapper) => T +>w : Wrapper + +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +>y : Wrapper<{ kind: "a"; a: 3; }> +>sepsis({ low: 1, sign: { kind: 'a', a: 3 }}) : Wrapper<{ kind: "a"; a: 3; }> +>sepsis : (opts: Opts) => Wrapper +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: "a"; a: 3; }; } +>low : number +>1 : 1 +>sign : { kind: "a"; a: 3; } +>{ kind: 'a', a: 3 } : { kind: "a"; a: 3; } +>kind : "a" +>'a' : "a" +>a : 3 +>3 : 3 + +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +>yun : { kind: "a"; a: 3; } +>unwrap(y) : { kind: "a"; a: 3; } +>unwrap : (w: Wrapper) => T +>y : Wrapper<{ kind: "a"; a: 3; }> + +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); +>yone : { kind: "a"; a: 3; } +>unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})) : { kind: "a"; a: 3; } +>unwrap : (w: Wrapper) => T +>sepsis({ low: 1, sign: { kind: 'a', a: 3 }}) : Wrapper<{ kind: "a"; a: 3; }> +>sepsis : (opts: Opts) => Wrapper +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: "a"; a: 3; }; } +>low : number +>1 : 1 +>sign : { kind: "a"; a: 3; } +>{ kind: 'a', a: 3 } : { kind: "a"; a: 3; } +>kind : "a" +>'a' : "a" +>a : 3 +>3 : 3 + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).js new file mode 100644 index 0000000000000..90085dfe2092f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +//// [returnTypeInferenceNotTooBroad.ts] +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +interface Opts { + low?: number; + sign?: T +} +interface Wrapper { +} +declare function sepsis(opts: Opts): Wrapper; +declare function unwrap(w: Wrapper): T; +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); + +//// [returnTypeInferenceNotTooBroad.js] +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 } }); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 } })); diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..ad8e148932bab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +=== returnTypeInferenceNotTooBroad.ts === +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 14)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 0, 25)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 37)) +>b : Symbol(b, Decl(returnTypeInferenceNotTooBroad.ts, 0, 48)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 60)) +>c : Symbol(c, Decl(returnTypeInferenceNotTooBroad.ts, 0, 71)) + +interface Opts { +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) + + low?: number; +>low : Symbol(Opts.low, Decl(returnTypeInferenceNotTooBroad.ts, 1, 19)) + + sign?: T +>sign : Symbol(Opts.sign, Decl(returnTypeInferenceNotTooBroad.ts, 2, 17)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) +} +interface Wrapper { +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 5, 18)) +} +declare function sepsis(opts: Opts): Wrapper; +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>opts : Symbol(opts, Decl(returnTypeInferenceNotTooBroad.ts, 7, 41)) +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) + +declare function unwrap(w: Wrapper): T; +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>w : Symbol(w, Decl(returnTypeInferenceNotTooBroad.ts, 8, 27)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) + +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 9, 25)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 9, 33)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 9, 41)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 9, 52)) + +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +>yun : Symbol(yun, Decl(returnTypeInferenceNotTooBroad.ts, 11, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) + +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); +>yone : Symbol(yone, Decl(returnTypeInferenceNotTooBroad.ts, 13, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 13, 35)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 13, 43)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 13, 51)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 13, 62)) + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types new file mode 100644 index 0000000000000..94962df020556 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +=== returnTypeInferenceNotTooBroad.ts === +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +>Signs : Signs +>kind : "a" +>a : 3 +>kind : "b" +>b : 2 +>kind : "c" +>c : 1 + +interface Opts { + low?: number; +>low : number | undefined + + sign?: T +>sign : T | undefined +} +interface Wrapper { +} +declare function sepsis(opts: Opts): Wrapper; +>sepsis : (opts: Opts) => Wrapper +>opts : Opts + +declare function unwrap(w: Wrapper): T; +>unwrap : (w: Wrapper) => T +>w : Wrapper + +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +>y : Wrapper<{ kind: "a"; a: 3; }> +>sepsis({ low: 1, sign: { kind: 'a', a: 3 }}) : Wrapper<{ kind: "a"; a: 3; }> +>sepsis : (opts: Opts) => Wrapper +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: "a"; a: 3; }; } +>low : number +>1 : 1 +>sign : { kind: "a"; a: 3; } +>{ kind: 'a', a: 3 } : { kind: "a"; a: 3; } +>kind : "a" +>'a' : "a" +>a : 3 +>3 : 3 + +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +>yun : { kind: "a"; a: 3; } +>unwrap(y) : { kind: "a"; a: 3; } +>unwrap : (w: Wrapper) => T +>y : Wrapper<{ kind: "a"; a: 3; }> + +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); +>yone : { kind: "a"; a: 3; } +>unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})) : { kind: "a"; a: 3; } +>unwrap : (w: Wrapper) => T +>sepsis({ low: 1, sign: { kind: 'a', a: 3 }}) : Wrapper<{ kind: "a"; a: 3; }> +>sepsis : (opts: Opts) => Wrapper +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: "a"; a: 3; }; } +>low : number +>1 : 1 +>sign : { kind: "a"; a: 3; } +>{ kind: 'a', a: 3 } : { kind: "a"; a: 3; } +>kind : "a" +>'a' : "a" +>a : 3 +>3 : 3 + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).errors.txt new file mode 100644 index 0000000000000..b56bf6531dd0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).errors.txt @@ -0,0 +1,24 @@ +sharedMemberLayoutThisIntersectionBase.ts(7,3): error TS2339: Property 'm' does not exist on type 'D<"b">'. +sharedMemberLayoutThisIntersectionBase.ts(12,3): error TS2339: Property 'm' does not exist on type 'C<"b">'. + + +==== sharedMemberLayoutThisIntersectionBase.ts (2 errors) ==== + interface A { kind: string; m: this["kind"] } + interface B { m: "a" } + type AB = A & B; + + interface D extends AB { kind: T } + declare let d: D<"b">; + d.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'D<"b">'. + + declare const ABCtor: new () => AB; + class C extends ABCtor { declare kind: T } + declare let c: C<"b">; + c.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'C<"b">'. + + export {}; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).symbols new file mode 100644 index 0000000000000..793b38f82728b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>kind : Symbol(A.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 13)) +>m : Symbol(A.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 27)) + +interface B { m: "a" } +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) +>m : Symbol(B.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 13)) + +type AB = A & B; +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) + +interface D extends AB { kind: T } +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>kind : Symbol(D.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) + +declare let d: D<"b">; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) + +d.m; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) + +declare const ABCtor: new () => AB; +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) + +class C extends ABCtor { declare kind: T } +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>kind : Symbol(C.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) + +declare let c: C<"b">; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) + +c.m; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).types new file mode 100644 index 0000000000000..41de65a71ea2f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>kind : string +>m : this["kind"] + +interface B { m: "a" } +>m : "a" + +type AB = A & B; +>AB : AB + +interface D extends AB { kind: T } +>kind : T + +declare let d: D<"b">; +>d : D<"b"> + +d.m; +>d.m : any +>d : D<"b"> +>m : any + +declare const ABCtor: new () => AB; +>ABCtor : new () => AB + +class C extends ABCtor { declare kind: T } +>C : C +>ABCtor : A & B +>kind : T + +declare let c: C<"b">; +>c : C<"b"> + +c.m; +>c.m : any +>c : C<"b"> +>m : any + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..b56bf6531dd0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).errors.txt @@ -0,0 +1,24 @@ +sharedMemberLayoutThisIntersectionBase.ts(7,3): error TS2339: Property 'm' does not exist on type 'D<"b">'. +sharedMemberLayoutThisIntersectionBase.ts(12,3): error TS2339: Property 'm' does not exist on type 'C<"b">'. + + +==== sharedMemberLayoutThisIntersectionBase.ts (2 errors) ==== + interface A { kind: string; m: this["kind"] } + interface B { m: "a" } + type AB = A & B; + + interface D extends AB { kind: T } + declare let d: D<"b">; + d.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'D<"b">'. + + declare const ABCtor: new () => AB; + class C extends ABCtor { declare kind: T } + declare let c: C<"b">; + c.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'C<"b">'. + + export {}; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..793b38f82728b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>kind : Symbol(A.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 13)) +>m : Symbol(A.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 27)) + +interface B { m: "a" } +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) +>m : Symbol(B.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 13)) + +type AB = A & B; +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) + +interface D extends AB { kind: T } +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>kind : Symbol(D.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) + +declare let d: D<"b">; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) + +d.m; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) + +declare const ABCtor: new () => AB; +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) + +class C extends ABCtor { declare kind: T } +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>kind : Symbol(C.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) + +declare let c: C<"b">; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) + +c.m; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).types new file mode 100644 index 0000000000000..41de65a71ea2f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>kind : string +>m : this["kind"] + +interface B { m: "a" } +>m : "a" + +type AB = A & B; +>AB : AB + +interface D extends AB { kind: T } +>kind : T + +declare let d: D<"b">; +>d : D<"b"> + +d.m; +>d.m : any +>d : D<"b"> +>m : any + +declare const ABCtor: new () => AB; +>ABCtor : new () => AB + +class C extends ABCtor { declare kind: T } +>C : C +>ABCtor : A & B +>kind : T + +declare let c: C<"b">; +>c : C<"b"> + +c.m; +>c.m : any +>c : C<"b"> +>m : any + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..1509944c6c1ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).errors.txt @@ -0,0 +1,16 @@ +signatureHelpInferenceQueryOrder.ts(7,30): error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. + + +==== signatureHelpInferenceQueryOrder.ts (1 errors) ==== + function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } + interface A { a: A; } + interface B extends A { b; } + + declare var a: A, b: B; + + var d = f(a, b, x => x, x => x); + ~ +!!! error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. +!!! related TS2728 signatureHelpInferenceQueryOrder.ts:3:25: 'b' is declared here. +!!! related TS6502 signatureHelpInferenceQueryOrder.ts:1:51: The expected type comes from the return type of this signature. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..e588ae57cb9ae --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +//// [signatureHelpInferenceQueryOrder.ts] +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +interface A { a: A; } +interface B extends A { b; } + +declare var a: A, b: B; + +var d = f(a, b, x => x, x => x); + + +//// [signatureHelpInferenceQueryOrder.js] +"use strict"; +function f(y, y1, p, p1) { return [y, p1(y)]; } +var d = f(a, b, x => x, x => x); diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..b19ea30bb2348 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>y1 : Symbol(y1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 22)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>p : Symbol(p, Decl(signatureHelpInferenceQueryOrder.ts, 0, 29)) +>z : Symbol(z, Decl(signatureHelpInferenceQueryOrder.ts, 0, 34)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 0, 51)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) + +interface A { a: A; } +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>a : Symbol(A.a, Decl(signatureHelpInferenceQueryOrder.ts, 1, 13)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) + +interface B extends A { b; } +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(B.b, Decl(signatureHelpInferenceQueryOrder.ts, 2, 23)) + +declare var a: A, b: B; +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) + +var d = f(a, b, x => x, x => x); +>d : Symbol(d, Decl(signatureHelpInferenceQueryOrder.ts, 6, 3)) +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..ece3363ee1b85 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>y : T +>y1 : U +>p : (z: U) => T +>z : U +>p1 : (x: T) => U +>x : T +>[y, p1(y)] : [T, U] +>y : T +>p1(y) : U +>p1 : (x: T) => U +>y : T + +interface A { a: A; } +>a : A + +interface B extends A { b; } +>b : any + +declare var a: A, b: B; +>a : A +>b : B + +var d = f(a, b, x => x, x => x); +>d : [A, B] +>f(a, b, x => x, x => x) : [A, B] +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>a : A +>b : B +>x => x : (x: B) => B +>x : B +>x : B +>x => x : (x: A) => A +>x : A +>x : A + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..1509944c6c1ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,16 @@ +signatureHelpInferenceQueryOrder.ts(7,30): error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. + + +==== signatureHelpInferenceQueryOrder.ts (1 errors) ==== + function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } + interface A { a: A; } + interface B extends A { b; } + + declare var a: A, b: B; + + var d = f(a, b, x => x, x => x); + ~ +!!! error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. +!!! related TS2728 signatureHelpInferenceQueryOrder.ts:3:25: 'b' is declared here. +!!! related TS6502 signatureHelpInferenceQueryOrder.ts:1:51: The expected type comes from the return type of this signature. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..e588ae57cb9ae --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +//// [signatureHelpInferenceQueryOrder.ts] +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +interface A { a: A; } +interface B extends A { b; } + +declare var a: A, b: B; + +var d = f(a, b, x => x, x => x); + + +//// [signatureHelpInferenceQueryOrder.js] +"use strict"; +function f(y, y1, p, p1) { return [y, p1(y)]; } +var d = f(a, b, x => x, x => x); diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..b19ea30bb2348 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>y1 : Symbol(y1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 22)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>p : Symbol(p, Decl(signatureHelpInferenceQueryOrder.ts, 0, 29)) +>z : Symbol(z, Decl(signatureHelpInferenceQueryOrder.ts, 0, 34)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 0, 51)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) + +interface A { a: A; } +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>a : Symbol(A.a, Decl(signatureHelpInferenceQueryOrder.ts, 1, 13)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) + +interface B extends A { b; } +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(B.b, Decl(signatureHelpInferenceQueryOrder.ts, 2, 23)) + +declare var a: A, b: B; +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) + +var d = f(a, b, x => x, x => x); +>d : Symbol(d, Decl(signatureHelpInferenceQueryOrder.ts, 6, 3)) +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..ece3363ee1b85 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>y : T +>y1 : U +>p : (z: U) => T +>z : U +>p1 : (x: T) => U +>x : T +>[y, p1(y)] : [T, U] +>y : T +>p1(y) : U +>p1 : (x: T) => U +>y : T + +interface A { a: A; } +>a : A + +interface B extends A { b; } +>b : any + +declare var a: A, b: B; +>a : A +>b : B + +var d = f(a, b, x => x, x => x); +>d : [A, B] +>f(a, b, x => x, x => x) : [A, B] +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>a : A +>b : B +>x => x : (x: B) => B +>x : B +>x : B +>x => x : (x: A) => A +>x : A +>x : A + diff --git a/tsc/testdata/baselines/reference/compiler/spreadUnionPropOverride.types b/tsc/testdata/baselines/reference/compiler/spreadUnionPropOverride.types index 56d9011592664..4f5783ece7680 100644 --- a/tsc/testdata/baselines/reference/compiler/spreadUnionPropOverride.types +++ b/tsc/testdata/baselines/reference/compiler/spreadUnionPropOverride.types @@ -182,8 +182,8 @@ declare const abc: A | B | C; >abc : A | B | C const obj5 = { ->obj5 : { id: string; name: string; } | { name: string; age: number; id: string; } | { name: string; id: string; } ->{ id: "123", ...abc,} : { id: string; name: string; } | { name: string; age: number; id: string; } | { name: string; id: string; } +>obj5 : { id: string; name: string; } | { name: string; id: string; } | { name: string; age: number; id: string; } +>{ id: "123", ...abc,} : { id: string; name: string; } | { name: string; id: string; } | { name: string; age: number; id: string; } id: "123", >id : string @@ -195,8 +195,8 @@ const obj5 = { }; // OK - id is only in A const obj6 = { ->obj6 : { id: string; name: string; } | { name: string; age: number; } | { name: string; } ->{ name: "test", ...abc,} : { id: string; name: string; } | { name: string; age: number; } | { name: string; } +>obj6 : { name: string; } | { id: string; name: string; } | { name: string; age: number; } +>{ name: "test", ...abc,} : { name: string; } | { id: string; name: string; } | { name: string; age: number; } name: "test", >name : string diff --git a/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.symbols b/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.symbols new file mode 100644 index 0000000000000..3b8125dec8b95 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.symbols @@ -0,0 +1,94 @@ +//// [tests/cases/compiler/substitutionInDeferredConditionalOfConditional.ts] //// + +=== substitutionInDeferredConditionalOfConditional.ts === +// Children always produces a Record, so it satisfies NeedsRecord. Its +// true branch narrows S["states"] to Record even when S is +// a conditional type that is itself deferred. + +interface Schema { +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) + + states?: Record; +>states : Symbol(Schema.states, Decl(substitutionInDeferredConditionalOfConditional.ts, 4, 18)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +} +type Resolve, Segments extends readonly string[]> = +>Resolve : Symbol(Resolve, Decl(substitutionInDeferredConditionalOfConditional.ts, 6, 1)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +>Segments : Symbol(Segments, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 46)) + + Segments extends [infer Head extends string, ...infer Rest extends string[]] +>Segments : Symbol(Segments, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 46)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>Rest : Symbol(Rest, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 57)) + + ? Head extends keyof S +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) + + ? Rest extends [] +>Rest : Symbol(Rest, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 57)) + + ? S[Head] +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) + + : S[Head]["states"] extends Record +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) + + ? Resolve +>Resolve : Symbol(Resolve, Decl(substitutionInDeferredConditionalOfConditional.ts, 6, 1)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>Rest : Symbol(Rest, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 57)) + + : never + : never + : never; +type Split